From 4c9b180431f81e42c1c3c5c98a4263edaa6025a9 Mon Sep 17 00:00:00 2001 From: Andrew Sliva Date: Mon, 2 Mar 2026 12:08:47 -0700 Subject: [PATCH 1/6] fix: improve reaction handling logic in Discord bot --- systems/docgpt/src/app/discord.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/systems/docgpt/src/app/discord.py b/systems/docgpt/src/app/discord.py index 21d21db..202a687 100644 --- a/systems/docgpt/src/app/discord.py +++ b/systems/docgpt/src/app/discord.py @@ -147,8 +147,20 @@ async def on_message( add_start_index=True, ).split_text(result.answer) + first_reply_message: discord.Message | None = None for reply in response_chunks: - await user_message.reply(reply) + sent = await user_message.reply(reply) + if first_reply_message is None: + first_reply_message = sent + + # Add feedback reactions to the assistant's first reply (the answer), + # not to the original user question message. + if first_reply_message is not None: + try: + await first_reply_message.add_reaction("👍") + await first_reply_message.add_reaction("👎") + except Exception: + log.exception("Failed to add feedback reactions to assistant reply") if channel.name.lower() == NEW_THREAD_NAME.lower(): title_result = assistant.prompt( From 2cdc4f2328ef0364a3e4801c39c1b0ff54db6f36 Mon Sep 17 00:00:00 2001 From: Andrew Sliva Date: Mon, 23 Mar 2026 11:37:21 -0700 Subject: [PATCH 2/6] add test environment config and related scripts for test infrastructure --- systems/docgpt/.env.test.example | 18 +++++++ systems/docgpt/README.md | 67 ++++++++++++++++++++++++++ systems/docgpt/docker-compose.test.yml | 31 ++++++++++++ systems/docgpt/run-test-bot.sh | 18 +++++++ 4 files changed, 134 insertions(+) create mode 100644 systems/docgpt/.env.test.example create mode 100644 systems/docgpt/docker-compose.test.yml create mode 100644 systems/docgpt/run-test-bot.sh diff --git a/systems/docgpt/.env.test.example b/systems/docgpt/.env.test.example new file mode 100644 index 0000000..360e6b0 --- /dev/null +++ b/systems/docgpt/.env.test.example @@ -0,0 +1,18 @@ +# Gemini API key (or set GOOGLE_API_KEY) +AI_GEMINI_APIKEY= + +# Discord bot token (use a dedicated test bot token) +APP_DISCORD_TOKEN= + +# Force pgvector backend for isolated test database runs +STORAGE_VECTOR_BACKEND=pgvector + +# PostgreSQL test database (docker-compose.test.yml) +# Format: postgresql+psycopg://USER:PASSWORD@HOST:PORT/DATABASE +STORAGE_VECTOR_URL=postgresql+psycopg://root:example@localhost:55432/docgpt_test + +# MongoDB test database (docker-compose.test.yml) +STORAGE_MEMORY_URL=mongodb://root:example@localhost:27018/docgpt_test + +# Optional +LOG_LEVEL=INFO diff --git a/systems/docgpt/README.md b/systems/docgpt/README.md index 2bbd56f..7e22a9d 100644 --- a/systems/docgpt/README.md +++ b/systems/docgpt/README.md @@ -25,3 +25,70 @@ Ask about the R data.table package documentation and contribution guide. 2. Run ```docker compose up``` 3. Ingest data (once): ```uv run python main.py --ingest``` 4. Start the Discord bot: ```uv run python main.py``` + +## Manual bot testing with separate test DB + +Use this flow when you want to interact with the bot in Discord without touching normal dev data. + +1. Create a test env file from the template: + ```powershell + Copy-Item .env.test.example .env.test + ``` +2. Fill in `AI_GEMINI_APIKEY` and `APP_DISCORD_TOKEN` in `.env.test`. +3. Start isolated test databases: + ```powershell + docker compose -f docker-compose.test.yml up -d + ``` +4. Load `.env.test` into the current PowerShell session: + ```powershell + Get-Content .env.test | ForEach-Object { + if ($_ -match '^\s*#' -or $_ -match '^\s*$') { return } + $name, $value = $_ -split '=', 2 + Set-Item -Path "Env:$name" -Value $value + } + ``` +5. Ingest documents into the test vector database: + ```powershell + uv run python main.py --ingest + ``` +6. Run the Discord bot using the test DB settings: + ```powershell + uv run python main.py + ``` +7. Tear down and wipe test data when done: + ```powershell + docker compose -f docker-compose.test.yml down -v + ``` + +This keeps vector data and chat memory isolated to test services (`localhost:55432`, `localhost:27018`) and removes persisted test data on teardown. + +## Run a second bot on EC2 (side-by-side with prod) + +Use this when your production bot is already running and you want a separate test bot process. + +1. Create a second Discord bot application/token (test-only) and add it to a test server. +2. Prepare test environment values: + ```bash + cp .env.test.example .env.test + ``` +3. Edit `.env.test` and set: + - `APP_DISCORD_TOKEN` to the test bot token + - `AI_GEMINI_APIKEY` +4. Ingest test data once: + ```bash + set -a && source .env.test && set +a + docker compose -f docker-compose.test.yml up -d + uv run python main.py --ingest + ``` +5. Run the second bot: + ```bash + ./run-test-bot.sh + ``` + +Notes: +- Do not reuse the production bot token for the test bot. +- Production bot keeps using `.env`; test bot uses `.env.test`. +- Stop and wipe test data when finished: + ```bash + docker compose -f docker-compose.test.yml down -v + ``` diff --git a/systems/docgpt/docker-compose.test.yml b/systems/docgpt/docker-compose.test.yml new file mode 100644 index 0000000..fe3794f --- /dev/null +++ b/systems/docgpt/docker-compose.test.yml @@ -0,0 +1,31 @@ +version: "3" + +services: + vector_storage_test: + image: ankane/pgvector + container_name: vector_storage_test + restart: always + ports: + - "55432:5432" + environment: + - POSTGRES_USER=root + - POSTGRES_PASSWORD=example + - POSTGRES_DB=docgpt_test + volumes: + - docgpt_test_postgres_data:/var/lib/postgresql/data + + memory_storage_test: + image: mongo + container_name: memory_storage_test + restart: always + ports: + - "27018:27017" + environment: + MONGO_INITDB_ROOT_USERNAME: root + MONGO_INITDB_ROOT_PASSWORD: example + volumes: + - docgpt_test_mongo_data:/data/db + +volumes: + docgpt_test_postgres_data: + docgpt_test_mongo_data: diff --git a/systems/docgpt/run-test-bot.sh b/systems/docgpt/run-test-bot.sh new file mode 100644 index 0000000..68af4a9 --- /dev/null +++ b/systems/docgpt/run-test-bot.sh @@ -0,0 +1,18 @@ +#!/usr/bin/env bash +set -euo pipefail + +if [[ ! -f ".env.test" ]]; then + echo ".env.test not found. Create it from .env.test.example first." + exit 1 +fi + +# Export all variables from .env.test for this shell. +set -a +source .env.test +set +a + +echo "Starting isolated test databases..." +docker compose -f docker-compose.test.yml up -d + +echo "Running second (test) bot with .env.test configuration..." +uv run python main.py From 1f5d2f34d08a41e794b32542e24abbf8fa185666 Mon Sep 17 00:00:00 2001 From: Andrew Sliva Date: Wed, 25 Mar 2026 12:06:56 -0700 Subject: [PATCH 3/6] Fix feedback option and citeation --- systems/docgpt/src/adapters/assistant.py | 24 ++++++++++- systems/docgpt/src/app/discord.py | 45 +++++++++++++++++++- systems/docgpt/src/logging/discord_logger.py | 36 ++++++++++++++-- 3 files changed, 99 insertions(+), 6 deletions(-) diff --git a/systems/docgpt/src/adapters/assistant.py b/systems/docgpt/src/adapters/assistant.py index 1b14fa1..b5c77ae 100644 --- a/systems/docgpt/src/adapters/assistant.py +++ b/systems/docgpt/src/adapters/assistant.py @@ -13,6 +13,25 @@ from src.port.assistant import AssistantPort +def _format_citations(source_docs: list[Any], max_sources: int = 5) -> str: + """Format source documents as a citation string appended to responses.""" + sources: list[str] = [] + seen: set[str] = set() + + for doc in source_docs: + metadata = getattr(doc, "metadata", {}) or {} + source = metadata.get("source") or metadata.get("file_path") or "" + if source and source not in seen: + seen.add(source) + sources.append(source) + if len(sources) >= max_sources: + break + + if sources: + return "\n\n**Sources:** " + ", ".join(sources) + return "" + + class ConversationalAssistantAdapter(AssistantPort): def __init__( self, @@ -141,8 +160,11 @@ def prompt_with_metadata( except Exception: llm_answer = None + citations = _format_citations(source_docs) + answer_with_citations = answer + citations if citations else answer + return { - "answer": answer, + "answer": answer_with_citations, "rag_context": rag_context, "llm_answer": llm_answer, "source_documents": source_docs, diff --git a/systems/docgpt/src/app/discord.py b/systems/docgpt/src/app/discord.py index 789aebf..b5a2aa1 100644 --- a/systems/docgpt/src/app/discord.py +++ b/systems/docgpt/src/app/discord.py @@ -11,10 +11,11 @@ __all__ = ("BOT",) -# Configure intents to allow fetching thread members +# Configure intents to allow fetching thread members and reactions intents = discord.Intents.default() intents.members = True intents.message_content = True +intents.reactions = True BOT = discord.Bot(auto_sync_commands=True, intents=intents) NEW_THREAD_NAME = "New Thread" @@ -55,6 +56,46 @@ async def on_thread_delete( assistant.clear_history(str(thread.id)) +@BOT.event +@inject +async def on_raw_reaction_add( + payload: discord.RawReactionActionEvent, + *, + interaction_logger: DiscordInteractionLogger = Provide[ + Settings.logging.discord_logger + ], +): + """Handle feedback reactions (thumbs up/down) on bot messages.""" + log = logging.getLogger(__name__) + + if BOT.user is None: + return + + if payload.user_id == BOT.user.id: + return + + emoji = str(payload.emoji) + if emoji not in ("👍", "👎"): + return + + thumbs_up = emoji == "👍" + reply_message_id = str(payload.message_id) + + try: + updated = interaction_logger.log_feedback( + discord_reply_message_id=reply_message_id, + thumbs_up=thumbs_up, + ) + if updated: + log.debug( + "Recorded feedback (thumbs_up=%s) for reply message %s", + thumbs_up, + reply_message_id, + ) + except Exception as e: + log.error("Failed to log feedback for message %s: %s", reply_message_id, e) + + @BOT.command(description="Sends help request") async def help_me(ctx: discord.ApplicationContext): # Defer immediately to prevent timeout (gives us up to 15 minutes to respond) @@ -162,6 +203,7 @@ async def on_message( await first_reply_message.add_reaction("👍") await first_reply_message.add_reaction("👎") except Exception: + log = logging.getLogger(__name__) log.exception("Failed to add feedback reactions to assistant reply") try: @@ -174,6 +216,7 @@ async def on_message( discord_channel_id=str(channel.id), discord_thread_id=str(channel.id), discord_message_id=str(message.id), + discord_reply_message_id=str(first_reply_message.id) if first_reply_message else None, ) except Exception as e: log = logging.getLogger(__name__) diff --git a/systems/docgpt/src/logging/discord_logger.py b/systems/docgpt/src/logging/discord_logger.py index dec15c9..aac3b99 100644 --- a/systems/docgpt/src/logging/discord_logger.py +++ b/systems/docgpt/src/logging/discord_logger.py @@ -20,6 +20,7 @@ class DiscordInteractionLogEntry: discord_channel_id: Optional[str] = None discord_thread_id: Optional[str] = None discord_message_id: Optional[str] = None + discord_reply_message_id: Optional[str] = None candidate_a_answer: Optional[str] = None candidate_b_answer: Optional[str] = None feedback_selected_candidate: Optional[str] = None @@ -52,6 +53,7 @@ def _ensure_schema(self) -> None: discord_channel_id TEXT NULL, discord_thread_id TEXT NULL, discord_message_id TEXT NULL, + discord_reply_message_id TEXT NULL, question TEXT NOT NULL, rag_answer TEXT NULL, rag_context TEXT NULL, @@ -64,6 +66,21 @@ def _ensure_schema(self) -> None: ); """ ) + cur.execute( + """ + DO $$ + BEGIN + IF NOT EXISTS ( + SELECT 1 FROM information_schema.columns + WHERE table_name = 'discord_interaction_logs' + AND column_name = 'discord_reply_message_id' + ) THEN + ALTER TABLE discord_interaction_logs + ADD COLUMN discord_reply_message_id TEXT NULL; + END IF; + END $$; + """ + ) cur.execute( "CREATE INDEX IF NOT EXISTS idx_discord_logs_created_at ON discord_interaction_logs(created_at);" ) @@ -73,6 +90,9 @@ def _ensure_schema(self) -> None: cur.execute( "CREATE INDEX IF NOT EXISTS idx_discord_logs_user_id ON discord_interaction_logs(discord_user_id);" ) + cur.execute( + "CREATE INDEX IF NOT EXISTS idx_discord_logs_reply_message_id ON discord_interaction_logs(discord_reply_message_id);" + ) conn.commit() def log_interaction( @@ -86,6 +106,7 @@ def log_interaction( discord_channel_id: Optional[str], discord_thread_id: Optional[str], discord_message_id: Optional[str], + discord_reply_message_id: Optional[str] = None, candidate_a_answer: Optional[str] = None, candidate_b_answer: Optional[str] = None, ) -> int: @@ -103,10 +124,11 @@ def log_interaction( discord_channel_id, discord_thread_id, discord_message_id, + discord_reply_message_id, candidate_a_answer, candidate_b_answer ) VALUES ( - %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s + %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s ) RETURNING id; """, @@ -120,6 +142,7 @@ def log_interaction( discord_channel_id, discord_thread_id, discord_message_id, + discord_reply_message_id, candidate_a_answer, candidate_b_answer, ), @@ -138,6 +161,7 @@ def log_entry(self, entry: DiscordInteractionLogEntry) -> int: discord_channel_id=entry.discord_channel_id, discord_thread_id=entry.discord_thread_id, discord_message_id=entry.discord_message_id, + discord_reply_message_id=entry.discord_reply_message_id, candidate_a_answer=entry.candidate_a_answer, candidate_b_answer=entry.candidate_b_answer, ) @@ -145,11 +169,14 @@ def log_entry(self, entry: DiscordInteractionLogEntry) -> int: def log_feedback( self, *, - discord_message_id: str, + discord_reply_message_id: str, thumbs_up: bool | None, ) -> bool: """Update feedback fields for an existing interaction log row. + Looks up the row by discord_reply_message_id (the bot's reply message) + since that's where feedback reactions are placed. + Returns True if a row was updated, otherwise False. """ with self._get_conn() as conn, conn.cursor() as cur: @@ -161,14 +188,14 @@ def log_feedback( WHEN %s IS NULL THEN NULL ELSE NOW() END - WHERE discord_message_id = %s + WHERE discord_reply_message_id = %s AND rag_name = %s RETURNING id; """, ( thumbs_up, thumbs_up, - discord_message_id, + discord_reply_message_id, self._rag_name, ), ) @@ -214,6 +241,7 @@ def export_csv( discord_channel_id, discord_thread_id, discord_message_id, + discord_reply_message_id, question, rag_answer, rag_context, From 53bff3ba31ec53ff835418a46cd3b8e2a93d2643 Mon Sep 17 00:00:00 2001 From: Andrew Sliva Date: Wed, 25 Mar 2026 13:05:57 -0700 Subject: [PATCH 4/6] Fix citation issues --- systems/docgpt/src/adapters/assistant.py | 85 ++++++++++++++++++++++-- systems/docgpt/src/core/containers.py | 4 +- systems/docgpt/src/core/prompts.py | 9 ++- 3 files changed, 88 insertions(+), 10 deletions(-) diff --git a/systems/docgpt/src/adapters/assistant.py b/systems/docgpt/src/adapters/assistant.py index b5c77ae..fd0e085 100644 --- a/systems/docgpt/src/adapters/assistant.py +++ b/systems/docgpt/src/adapters/assistant.py @@ -13,23 +13,94 @@ from src.port.assistant import AssistantPort +def _extract_section_title(content: str) -> str | None: + """Extract the first markdown heading or code section from content.""" + import re + + heading_match = re.search(r'^#{1,6}\s+(.+)$', content, re.MULTILINE) + if heading_match: + return heading_match.group(1).strip() + + func_match = re.search(r'^(?:def|class|function)\s+(\w+)', content, re.MULTILINE) + if func_match: + return func_match.group(1) + + r_func_match = re.search(r'^(\w+)\s*<-\s*function', content, re.MULTILINE) + if r_func_match: + return r_func_match.group(1) + + return None + + def _format_citations(source_docs: list[Any], max_sources: int = 5) -> str: - """Format source documents as a citation string appended to responses.""" + """Format source documents as a citation string appended to responses. + + Includes file paths, line numbers (when available), and section titles. + """ + citations: list[str] = [] + seen: set[str] = set() + + for i, doc in enumerate(source_docs): + if len(citations) >= max_sources: + break + + metadata = getattr(doc, "metadata", {}) or {} + source = metadata.get("source") or metadata.get("file_path") or "" + start_index = metadata.get("start_index") + page_content = getattr(doc, "page_content", "") or "" + + if not source: + continue + + citation_key = source + if start_index is not None: + citation_key = f"{source}:{start_index}" + + if citation_key in seen: + continue + seen.add(citation_key) + + citation_parts = [f"[{len(citations) + 1}]", f"`{source}`"] + + details: list[str] = [] + + if start_index is not None and start_index > 0: + avg_chars_per_line = 60 + approx_line = (start_index // avg_chars_per_line) + 1 + details.append(f"line ~{approx_line}") + + section_title = _extract_section_title(page_content) + if section_title: + section_display = section_title[:50] + "..." if len(section_title) > 50 else section_title + details.append(f'"{section_display}"') + + if details: + citation_parts.append(f"({', '.join(details)})") + + citations.append(" ".join(citation_parts)) + + if citations: + return "\n\n**Sources:**\n" + "\n".join(citations) + return "" + + +def _build_source_context(source_docs: list[Any], max_sources: int = 5) -> str: + """Build a source reference list for the LLM to use in inline citations.""" sources: list[str] = [] seen: set[str] = set() for doc in source_docs: + if len(sources) >= max_sources: + break + metadata = getattr(doc, "metadata", {}) or {} source = metadata.get("source") or metadata.get("file_path") or "" + if source and source not in seen: seen.add(source) - sources.append(source) - if len(sources) >= max_sources: - break + sources.append(f"[{len(sources) + 1}] {source}") - if sources: - return "\n\n**Sources:** " + ", ".join(sources) - return "" + return "\n".join(sources) if sources else "" class ConversationalAssistantAdapter(AssistantPort): diff --git a/systems/docgpt/src/core/containers.py b/systems/docgpt/src/core/containers.py index bb55c6d..6edcc94 100644 --- a/systems/docgpt/src/core/containers.py +++ b/systems/docgpt/src/core/containers.py @@ -112,7 +112,9 @@ class ContentAdapters(containers.DeclarativeContainer): converter: Singleton[ContentConverterPort] = Singleton(PandocConverterAdapter) splitter_factory: Factory[LangSplitterByMetadata] = Factory(LangSplitterByMetadata) - git_splitter: Singleton[TextSplitter] = Singleton(splitter_factory, "file_name") + git_splitter: Singleton[TextSplitter] = Singleton( + splitter_factory, "file_name", add_start_index=True + ) git_code: Singleton[ContentPort] = Singleton( GitCodeContentAdapter, splitter=git_splitter, diff --git a/systems/docgpt/src/core/prompts.py b/systems/docgpt/src/core/prompts.py index 8ee1420..c7f56ca 100644 --- a/systems/docgpt/src/core/prompts.py +++ b/systems/docgpt/src/core/prompts.py @@ -33,8 +33,13 @@ Style rules: - Write like a natural conversation (short paragraphs). - Avoid bullet points unless the user explicitly asks for a list. -- Keep it short: aim for 3–6 sentences, ideally under ~150 words, unless the user asks for more depth. -- When helpful, mention a specific function/file/section from the context, but don’t over-cite. +- Keep it short: aim for 3-6 sentences, ideally under ~150 words, unless the user asks for more depth. + +Citation rules: +- Use inline citations to reference your sources. Cite using brackets with numbers, e.g., [1], [2]. +- When mentioning specific functions, files, or code sections, include the citation number. +- Example: "The fread() function handles CSV parsing [1] and supports automatic type detection [2]." +- Only cite sources you actually use from the context. Context: {context} From 40590f649473cb866952d493bb2a01b37b9743ee Mon Sep 17 00:00:00 2001 From: Andrew Sliva Date: Mon, 6 Apr 2026 12:15:30 -0700 Subject: [PATCH 5/6] Add OpenRAG-DB-viewer app, CI workflow, and initial utilities - Add app core files (`app.py`, `db_utils.py`, `diff_utils.py`) - Add documentation: `README.md` - Add database connection scripts: `connect.sh`, `connect.ps1` - Add CI GitHub workflow for CI checks - Add Python requirements for the project - Initial `.gitignore` for OpenRAG-DB-viewer - Remove obsolete `systems/docgpt/.env.example` - Add new `systems/docgpt/.env.test` for test configuration --- OpenRAG-DB-viewer/.github/workflows/ci.yml | 95 +++++ OpenRAG-DB-viewer/.gitignore | 7 + OpenRAG-DB-viewer/README.md | 148 +++++++ OpenRAG-DB-viewer/app.py | 452 +++++++++++++++++++++ OpenRAG-DB-viewer/connect.ps1 | 92 +++++ OpenRAG-DB-viewer/connect.sh | 80 ++++ OpenRAG-DB-viewer/db_utils.py | 388 ++++++++++++++++++ OpenRAG-DB-viewer/diff_utils.py | 97 +++++ OpenRAG-DB-viewer/requirements.txt | 3 + 9 files changed, 1362 insertions(+) create mode 100644 OpenRAG-DB-viewer/.github/workflows/ci.yml create mode 100644 OpenRAG-DB-viewer/.gitignore create mode 100644 OpenRAG-DB-viewer/README.md create mode 100644 OpenRAG-DB-viewer/app.py create mode 100644 OpenRAG-DB-viewer/connect.ps1 create mode 100644 OpenRAG-DB-viewer/connect.sh create mode 100644 OpenRAG-DB-viewer/db_utils.py create mode 100644 OpenRAG-DB-viewer/diff_utils.py create mode 100644 OpenRAG-DB-viewer/requirements.txt diff --git a/OpenRAG-DB-viewer/.github/workflows/ci.yml b/OpenRAG-DB-viewer/.github/workflows/ci.yml new file mode 100644 index 0000000..de74b79 --- /dev/null +++ b/OpenRAG-DB-viewer/.github/workflows/ci.yml @@ -0,0 +1,95 @@ +name: CI + +on: + push: + branches: [main] + pull_request: + branches: [main] + +jobs: + smoke-test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Install dependencies + run: pip install -r requirements.txt + + - name: Import check + run: python -c "import db_utils; import diff_utils; print('Imports OK')" + + - name: SQL validation tests + run: | + python -c " + import db_utils + + # Should pass + assert db_utils.validate_readonly('SELECT * FROM t') is None + assert db_utils.validate_readonly('WITH cte AS (SELECT 1) SELECT * FROM cte') is None + assert db_utils.validate_readonly('EXPLAIN QUERY PLAN SELECT 1') is None + assert db_utils.validate_readonly('EXPLAIN ANALYZE SELECT 1') is None + + # Should block + assert db_utils.validate_readonly('DROP TABLE t') is not None + assert db_utils.validate_readonly('INSERT INTO t VALUES (1)') is not None + assert db_utils.validate_readonly('UPDATE t SET x=1') is not None + assert db_utils.validate_readonly('DELETE FROM t') is not None + assert db_utils.validate_readonly('') is not None + + print('All SQL validation tests passed') + " + + - name: Diff utils tests + run: | + python -c " + import diff_utils + + assert diff_utils.jaccard_similarity('hello world', 'hello there') > 0 + assert diff_utils.jaccard_similarity('', '') == 1.0 + assert diff_utils.answer_length('test') == 4 + assert diff_utils.answer_length(None) == 0 + assert diff_utils.token_count('hello world') == 2 + + print('All diff utils tests passed') + " + + release: + needs: smoke-test + if: github.event_name == 'push' && github.ref == 'refs/heads/main' + runs-on: ubuntu-latest + permissions: + contents: write + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Generate version tag + id: tag + run: | + TAG="v$(date -u +%Y%m%d.%H%M%S)" + echo "tag=$TAG" >> "$GITHUB_OUTPUT" + + - name: Create GitHub Release + uses: softprops/action-gh-release@v2 + with: + tag_name: ${{ steps.tag.outputs.tag }} + name: ${{ steps.tag.outputs.tag }} + body: | + Automated release from push to main. + + ## Quick start + ```bash + pip install -r requirements.txt + # Local (direct connection): + streamlit run app.py + # Via EC2 SSH tunnel (Windows): + .\connect.ps1 -SshKey "~\.ssh\key.pem" -Ec2Host "YOUR_EC2_IP" + # Via EC2 SSH tunnel (Linux/macOS): + ./connect.sh -k ~/.ssh/key.pem -h YOUR_EC2_IP + ``` + generate_release_notes: true diff --git a/OpenRAG-DB-viewer/.gitignore b/OpenRAG-DB-viewer/.gitignore new file mode 100644 index 0000000..2fb4352 --- /dev/null +++ b/OpenRAG-DB-viewer/.gitignore @@ -0,0 +1,7 @@ +__pycache__/ +*.pyc +*.pyo +*.db +.env +.venv/ +venv/ diff --git a/OpenRAG-DB-viewer/README.md b/OpenRAG-DB-viewer/README.md new file mode 100644 index 0000000..21c9561 --- /dev/null +++ b/OpenRAG-DB-viewer/README.md @@ -0,0 +1,148 @@ +# OpenRAG Responses DB Viewer + +A local Streamlit web UI for inspecting, filtering, and exporting evaluation +responses stored in either: + +- **PostgreSQL** -- the `discord_interaction_logs` table (user messages, RAG + answers, LLM answers, Discord metadata, candidate answers, feedback) +- **SQLite** -- the `evaluation_logs` table (evaluation pipeline results) +- **Any table** -- the viewer auto-discovers all tables in the database and lets + you pick which one to browse. + +Built for the [OpenRAG](https://github.com/RESHAPELab/OpenRAG) project. + +## Features + +- **Dual backend** -- switch between PostgreSQL and SQLite via a sidebar toggle. +- **Auto table discovery** -- connects and lists all available tables; no + hard-coded table names required. +- **Configurable connection** -- enter a DSN for PostgreSQL or a file path for + SQLite. Supports `DB_VIEWER_DSN` env var for automation. +- **Dynamic schema** -- columns, filters, and dropdowns adapt automatically. +- **Filtering** -- dropdown filters, timestamp range with presets (24h/7d/30d), + free-text search, answer presence checks, min-length, ID range. +- **Pagination & sorting** -- browse large result sets efficiently. +- **Column visibility toggles** -- hide/show any column. +- **Row detail panel** -- full wrapped text, candidate answers, feedback info. +- **Diff view** -- side-by-side, inline word-diff, or unified diff between + `rag_answer` and `llm_answer`, plus Jaccard overlap score. +- **Export** -- download filtered results as CSV or JSONL. +- **Read-only SQL console** -- run arbitrary `SELECT` queries with optional + `EXPLAIN QUERY PLAN` (SQLite) or `EXPLAIN ANALYZE` (PostgreSQL). + +## Prerequisites + +- Python 3.10+ +- pip +- For EC2 connection: SSH access with a `.pem` key file + +## Installation + +```bash +pip install -r requirements.txt +``` + +## Running the viewer + +### Option 1: Direct connection (local database) + +```bash +streamlit run app.py +``` + +Then configure the DSN or file path in the sidebar. + +### Option 2: Connect to EC2 via SSH tunnel (recommended for production data) + +The production Discord bot runs on an Amazon EC2 instance. The connect scripts +handle the SSH tunnel automatically. + +**Windows (PowerShell):** + +```powershell +.\connect.ps1 -SshKey "C:\path\to\your-key.pem" -Ec2Host "YOUR_EC2_IP" -Ec2User "YOUR_USER" +``` + +**Linux / macOS:** + +```bash +chmod +x connect.sh +./connect.sh -k ~/.ssh/your-key.pem -h YOUR_EC2_IP -u YOUR_USER +``` + +The scripts will: +1. Open an SSH tunnel (`localhost:15432 -> EC2:5432`) +2. Set the `DB_VIEWER_DSN` environment variable +3. Launch Streamlit +4. Clean up the tunnel on exit + +**Environment variables (optional, avoids typing every time):** + +| Variable | Description | Example | +|---|---|---| +| `EC2_SSH_KEY_PATH` | Path to `.pem` file | `~/.ssh/my-key.pem` | +| `EC2_HOST` | EC2 public IP or hostname | `3.14.15.92` | +| `EC2_SSH_USER` | SSH username | `ubuntu` | +| `DB_VIEWER_DSN` | Full PostgreSQL DSN (overrides sidebar default) | `postgresql://root:example@localhost:15432/postgres` | + +### Option 3: Manual SSH tunnel + +If you prefer to manage the tunnel yourself: + +```bash +# Terminal 1: open the tunnel +ssh -i ~/.ssh/your-key.pem -L 15432:localhost:5432 -N your_user@YOUR_EC2_IP + +# Terminal 2: run the viewer +set DB_VIEWER_DSN=postgresql://root:example@localhost:15432/postgres +streamlit run app.py +``` + +## CI / GitHub Actions + +On push to `main`, the workflow in `.github/workflows/ci.yml`: +1. Runs import checks and unit tests (SQL validation, diff utilities) +2. Creates an auto-tagged GitHub Release + +### GitHub Secrets (for future CI enhancements) + +If you want CI to run integration tests against EC2: + +| Secret | Description | +|---|---| +| `EC2_HOST` | EC2 public IP or hostname | +| `EC2_SSH_USER` | SSH username | +| `EC2_SSH_KEY` | Contents of the `.pem` private key | + +## Manual test steps + +1. **Launch viewer** -- `streamlit run app.py`, select PostgreSQL, enter DSN. +2. **Verify table discovery** -- confirm the table dropdown shows available tables. +3. **Verify rows load** sorted newest-first. +4. **Filter by dropdown** -- select a value, confirm table updates. +5. **Free-text search** -- type a keyword from a known question. +6. **Export CSV** -- click "Export CSV", open the file, verify contents. +7. **Row detail** -- select a row ID, verify all columns display. +8. **Diff view** -- switch to Diff View tab, enter a row ID, verify + side-by-side display and Jaccard score. +9. **SQL console** -- run `SELECT COUNT(*) FROM discord_interaction_logs;` +10. **SQL guard** -- try `DROP TABLE discord_interaction_logs;`, confirm blocked. +11. **Bad connection** -- enter a bogus DSN, confirm friendly error message. + +## Project structure + +``` +OpenRAG-DB-viewer/ + app.py Streamlit entrypoint (dual-backend UI) + db_utils.py Database connection, query builder, export helpers + diff_utils.py Diff rendering and text-similarity metrics + connect.ps1 Windows launch script with SSH tunnel + connect.sh Linux/macOS launch script with SSH tunnel + requirements.txt Python dependencies + .github/workflows/ CI: smoke tests + auto-release + README.md This file +``` + +## License + +Same as the parent OpenRAG project. diff --git a/OpenRAG-DB-viewer/app.py b/OpenRAG-DB-viewer/app.py new file mode 100644 index 0000000..ef4e612 --- /dev/null +++ b/OpenRAG-DB-viewer/app.py @@ -0,0 +1,452 @@ +"""OpenRAG Responses DB Viewer -- Streamlit application. + +Supports both SQLite and PostgreSQL. Auto-discovers tables in the database +and lets you pick which one to browse. +""" + +from __future__ import annotations + +import math +import os +from datetime import datetime, timedelta + +import pandas as pd +import streamlit as st + +import db_utils +import diff_utils + +# --------------------------------------------------------------------------- +# Page config +# --------------------------------------------------------------------------- + +st.set_page_config( + page_title="OpenRAG DB Viewer", + page_icon=":mag:", + layout="wide", +) + +# --------------------------------------------------------------------------- +# Sidebar -- DB connection +# --------------------------------------------------------------------------- + +st.sidebar.title("OpenRAG DB Viewer") + +backend = st.sidebar.radio( + "Database backend", + ["PostgreSQL", "SQLite"], + horizontal=True, + help="PostgreSQL for live databases (e.g. discord_interaction_logs). " + "SQLite for evaluation_logs .db files.", +) + +# ---- Step 1: Discover tables ---- +tables: list[str] = [] +conn_error: str | None = None + +if backend == "SQLite": + db_path = st.sidebar.text_input( + "SQLite DB path", + value="evaluation_logs.db", + help="Absolute or relative path to a SQLite file.", + ) + try: + tables = db_utils.list_sqlite_tables(db_path) + except FileNotFoundError as exc: + conn_error = str(exc) + except Exception as exc: # noqa: BLE001 + conn_error = f"Unexpected error: {exc}" +else: + dsn = st.sidebar.text_input( + "PostgreSQL DSN", + value=os.environ.get("DB_VIEWER_DSN", "postgresql://root:example@localhost:5432/postgres"), + help="Connection string for the PostgreSQL database. " + "Set DB_VIEWER_DSN env var to override the default.", + ) + try: + tables = db_utils.list_pg_tables(dsn) + except Exception as exc: # noqa: BLE001 + conn_error = f"Connection failed: {exc}" + +if conn_error: + st.error(conn_error) + st.stop() + +if not tables: + st.warning("No tables found in this database. The database appears to be empty.") + st.info( + "For the Discord interaction logs, the `discord_interaction_logs` table " + "is created automatically the first time the Discord bot logs an interaction. " + "Run the bot at least once, then refresh." + ) + st.stop() + +# ---- Step 2: Pick a table ---- +# Put well-known tables first +priority = ["discord_interaction_logs", "evaluation_logs"] +ordered = [t for t in priority if t in tables] + [t for t in tables if t not in priority] +selected_table = st.sidebar.selectbox("Table", ordered) + +# ---- Step 3: Connect to the selected table ---- +db: db_utils.DBConn | None = None +try: + if backend == "SQLite": + db = db_utils.connect_sqlite(db_path, selected_table) + else: + db = db_utils.connect_postgresql(dsn, selected_table) +except Exception as exc: # noqa: BLE001 + st.error(f"Failed to open table: {exc}") + st.stop() + +assert db is not None + +st.sidebar.caption(f"Connected to **{db.table}** ({len(db.columns)} columns)") + +# --------------------------------------------------------------------------- +# Sidebar -- Filters +# --------------------------------------------------------------------------- + +st.sidebar.markdown("---") +st.sidebar.subheader("Filters") + +dropdown_selections: dict[str, str | None] = {} +for col in db.filterable_dropdowns: + values = db_utils.get_distinct_values(db, col) + sel = st.sidebar.selectbox(col, ["All"] + values, index=0, key=f"dd_{col}") + dropdown_selections[col] = sel if sel != "All" else None + +ts_col_name = db.timestamp_col +st.sidebar.markdown(f"**{ts_col_name} range**") +ts_preset = st.sidebar.selectbox( + "Quick preset", ["None", "Last 24 hours", "Last 7 days", "Last 30 days"] +) +ts_from_val = "" +ts_to_val = "" +if ts_preset == "Last 24 hours": + ts_from_val = (datetime.utcnow() - timedelta(hours=24)).strftime("%Y-%m-%d %H:%M:%S") +elif ts_preset == "Last 7 days": + ts_from_val = (datetime.utcnow() - timedelta(days=7)).strftime("%Y-%m-%d %H:%M:%S") +elif ts_preset == "Last 30 days": + ts_from_val = (datetime.utcnow() - timedelta(days=30)).strftime("%Y-%m-%d %H:%M:%S") + +ts_from = st.sidebar.text_input("From (ISO)", value=ts_from_val) +ts_to = st.sidebar.text_input("To (ISO)", value=ts_to_val) + +# Free-text search across text-like columns +text_cols_available = [c for c in db.columns if c not in ("id",)] +search_text = st.sidebar.text_input( + "Search text", + help=f"Searches across text columns in {db.table}", +) + +# Advanced filters -- only show if rag_answer/llm_answer exist +has_answer_cols = "rag_answer" in db.columns or "llm_answer" in db.columns +with st.sidebar.expander("Advanced filters"): + answer_filter = "No filter" + min_rag_len = 0 + min_llm_len = 0 + if has_answer_cols: + answer_filter = st.selectbox( + "Answer presence", + ["No filter", "Has RAG answer", "Has LLM answer", "Missing either"], + ) + if "rag_answer" in db.columns: + min_rag_len = st.number_input("Min RAG answer length", min_value=0, value=0, step=10) + if "llm_answer" in db.columns: + min_llm_len = st.number_input("Min LLM answer length", min_value=0, value=0, step=10) + + id_min = 0 + id_max = 0 + if "id" in db.columns: + id_min = st.number_input("ID min", min_value=0, value=0, step=1) + id_max = st.number_input("ID max", min_value=0, value=0, step=1) + +# Sort & pagination +st.sidebar.markdown("---") +st.sidebar.subheader("Display") +sort_col = st.sidebar.selectbox("Sort by", db.sortable, index=0) +sort_dir = st.sidebar.radio("Sort direction", ["DESC", "ASC"], horizontal=True) +page_size = st.sidebar.selectbox("Rows per page", [25, 50, 100, 200], index=1) + +# Column visibility +with st.sidebar.expander("Column visibility"): + col_visibility: dict[str, bool] = {} + important = {"id", ts_col_name, "question", "rag_context", "rag_answer", "llm_answer", + "rag_name", "category", "model_name"} + for col in db.columns: + col_visibility[col] = st.checkbox(col, value=(col in important), key=f"vis_{col}") + +visible_cols = [c for c, shown in col_visibility.items() if shown] + +# Build Filters +has_rag = None +has_llm = None +missing_either = False +if answer_filter == "Has RAG answer": + has_rag = True +elif answer_filter == "Has LLM answer": + has_llm = True +elif answer_filter == "Missing either": + missing_either = True + +filters = db_utils.Filters( + ts_from=ts_from or None, + ts_to=ts_to or None, + search_text=search_text or None, + search_columns=text_cols_available, + has_rag=has_rag, + has_llm=has_llm, + missing_either=missing_either, + min_rag_len=min_rag_len if min_rag_len > 0 else None, + min_llm_len=min_llm_len if min_llm_len > 0 else None, + id_min=id_min if id_min > 0 else None, + id_max=id_max if id_max > 0 else None, + sort_col=sort_col, + sort_dir=sort_dir, + page=1, + page_size=page_size, + dropdown_filters={k: v for k, v in dropdown_selections.items() if v is not None}, +) + +# --------------------------------------------------------------------------- +# Main area +# --------------------------------------------------------------------------- + +tab_table, tab_diff, tab_sql = st.tabs( + ["Table View", "Diff View", "SQL Console"] +) + +# =========================== TABLE VIEW ================================== +with tab_table: + total = db_utils.fetch_count(db, filters) + total_pages = max(1, math.ceil(total / page_size)) + + col_pg1, col_pg2, col_pg3 = st.columns([1, 2, 1]) + with col_pg2: + page = st.number_input( + "Page", + min_value=1, + max_value=total_pages, + value=1, + step=1, + key="table_page", + ) + filters.page = page + + st.caption( + f"**{total}** rows match · page {page}/{total_pages} · " + f"table: `{db.table}`" + ) + + df = db_utils.fetch_rows(db, filters) + + if df.empty: + st.info("No rows match your filters.") + else: + avail_visible = [c for c in visible_cols if c in df.columns] + display_df = df[avail_visible] if avail_visible else df + + # Export + exp1, exp2, _ = st.columns([1, 1, 4]) + export_filters = db_utils.Filters( + ts_from=filters.ts_from, + ts_to=filters.ts_to, + search_text=filters.search_text, + search_columns=filters.search_columns, + has_rag=filters.has_rag, + has_llm=filters.has_llm, + missing_either=filters.missing_either, + min_rag_len=filters.min_rag_len, + min_llm_len=filters.min_llm_len, + id_min=filters.id_min, + id_max=filters.id_max, + sort_col=filters.sort_col, + sort_dir=filters.sort_dir, + page=1, + page_size=999_999_999, + dropdown_filters=filters.dropdown_filters, + ) + with exp1: + all_df = db_utils.fetch_rows(db, export_filters) + st.download_button( + "Export CSV", + data=db_utils.to_csv_bytes(all_df), + file_name=f"{db.table}_export.csv", + mime="text/csv", + ) + with exp2: + st.download_button( + "Export JSONL", + data=db_utils.to_jsonl_bytes(all_df), + file_name=f"{db.table}_export.jsonl", + mime="application/jsonl", + ) + + st.dataframe(display_df, use_container_width=True, hide_index=True) + + # ---- Detail panel ---- + st.markdown("---") + st.subheader("Row detail") + pk_col = "id" if "id" in df.columns else df.columns[0] + row_ids = df[pk_col].tolist() + if row_ids: + selected_id = st.selectbox( + f"Select {pk_col} to inspect", row_ids, key="detail_id" + ) + row = db_utils.fetch_row_by_id(db, selected_id) + if row: + for col_name in db.columns: + val = row.get(col_name, "") + expand = col_name in ("rag_answer", "llm_answer", "question") + with st.expander(f"**{col_name}**", expanded=expand): + st.code(str(val) if val is not None else "(NULL)", language=None) + + # Metrics (only if rag/llm columns exist) + if "rag_answer" in db.columns and "llm_answer" in db.columns: + st.markdown("**Quick metrics**") + m1, m2, m3 = st.columns(3) + rag_text = str(row.get("rag_answer") or "") + llm_text = str(row.get("llm_answer") or "") + m1.metric( + "RAG answer length", + f"{diff_utils.answer_length(rag_text)} chars / " + f"{diff_utils.token_count(rag_text)} tokens", + ) + m2.metric( + "LLM answer length", + f"{diff_utils.answer_length(llm_text)} chars / " + f"{diff_utils.token_count(llm_text)} tokens", + ) + m3.metric( + "Jaccard overlap", + f"{diff_utils.jaccard_similarity(rag_text, llm_text):.2%}", + ) + + if "candidate_a_answer" in row and row.get("candidate_a_answer"): + st.markdown("**Candidate A vs B**") + ca, cb = st.columns(2) + with ca: + st.text_area( + "Candidate A", + value=str(row.get("candidate_a_answer") or ""), + height=150, disabled=True, key=f"cand_a_{selected_id}", + ) + with cb: + st.text_area( + "Candidate B", + value=str(row.get("candidate_b_answer") or ""), + height=150, disabled=True, key=f"cand_b_{selected_id}", + ) + + if "feedback_thumbs_up" in row and row.get("feedback_thumbs_up") is not None: + fb = row["feedback_thumbs_up"] + st.info( + f"Feedback: {'Thumbs up' if fb else 'Thumbs down'} " + f"(at {row.get('feedback_timestamp', 'N/A')})" + ) + +# =========================== DIFF VIEW =================================== +with tab_diff: + if "rag_answer" not in db.columns or "llm_answer" not in db.columns: + st.info( + f"Diff View requires `rag_answer` and `llm_answer` columns. " + f"Table `{db.table}` does not have them." + ) + else: + st.subheader("RAG vs LLM Answer Diff") + + diff_row_id = st.number_input("Enter row ID", min_value=1, step=1, key="diff_row_id") + diff_row = db_utils.fetch_row_by_id(db, int(diff_row_id)) + + if diff_row is None: + st.warning(f"Row {diff_row_id} not found.") + else: + rag_text = str(diff_row.get("rag_answer") or "") + llm_text = str(diff_row.get("llm_answer") or "") + + if "question" in diff_row: + st.caption(f"**Question:** {diff_row.get('question', '')}") + + mc1, mc2, mc3 = st.columns(3) + mc1.metric("RAG length", f"{diff_utils.answer_length(rag_text)} chars") + mc2.metric("LLM length", f"{diff_utils.answer_length(llm_text)} chars") + mc3.metric("Jaccard overlap", f"{diff_utils.jaccard_similarity(rag_text, llm_text):.2%}") + + diff_mode = st.radio( + "Diff style", + ["Side-by-side (highlighted)", "Inline word diff", "Unified diff"], + horizontal=True, + ) + + if diff_mode == "Side-by-side (highlighted)": + html_table = diff_utils.side_by_side_html(rag_text, llm_text) + st.markdown( + f'
{html_table}
', + unsafe_allow_html=True, + ) + elif diff_mode == "Inline word diff": + html_a, html_b = diff_utils.inline_diff_html(rag_text, llm_text) + c1, c2 = st.columns(2) + with c1: + st.markdown("**RAG Answer**") + st.markdown( + f'
{html_a}
', + unsafe_allow_html=True, + ) + with c2: + st.markdown("**LLM Answer**") + st.markdown( + f'
{html_b}
', + unsafe_allow_html=True, + ) + elif diff_mode == "Unified diff": + diff_text = diff_utils.unified_diff_text(rag_text, llm_text) + if diff_text: + st.code(diff_text, language="diff") + else: + st.info("No differences found (texts are identical).") + +# =========================== SQL CONSOLE ================================= +with tab_sql: + st.subheader("Read-only SQL Console") + + all_tables_str = ", ".join(f"`{t}`" for t in tables) + st.caption( + f"Only `SELECT` (and `WITH ... SELECT`) queries are allowed. " + f"Available tables: {all_tables_str}" + ) + + default_sql = f"SELECT * FROM {db.table} LIMIT 20;" + sql_input = st.text_area( + "SQL query", + value=default_sql, + height=120, + key="sql_console_input", + ) + + explain_label = ( + "Show EXPLAIN QUERY PLAN" if db.backend == "sqlite" else "Show EXPLAIN ANALYZE" + ) + show_plan = st.checkbox(explain_label, key="sql_show_plan") + + if st.button("Run query", key="sql_run"): + query_to_run = sql_input.strip() + if show_plan: + prefix = "EXPLAIN QUERY PLAN" if db.backend == "sqlite" else "EXPLAIN ANALYZE" + query_to_run = f"{prefix} {query_to_run}" + + err = db_utils.validate_readonly(sql_input.strip()) + if err: + st.error(f"Blocked: {err}") + else: + try: + result_df = db_utils.run_readonly_sql(db, query_to_run) + if result_df.empty: + st.info("Query returned no rows.") + else: + st.dataframe(result_df, use_container_width=True, hide_index=True) + st.caption(f"{len(result_df)} row(s) returned.") + except Exception as exc: # noqa: BLE001 + st.error(f"Query error: {exc}") diff --git a/OpenRAG-DB-viewer/connect.ps1 b/OpenRAG-DB-viewer/connect.ps1 new file mode 100644 index 0000000..d3fc9d4 --- /dev/null +++ b/OpenRAG-DB-viewer/connect.ps1 @@ -0,0 +1,92 @@ +<# +.SYNOPSIS + Launch the DB Viewer with an SSH tunnel to an EC2 PostgreSQL instance. + +.PARAMETER SshKey + Path to the .pem SSH private key file. + Defaults to env var EC2_SSH_KEY_PATH. + +.PARAMETER Ec2Host + EC2 public IP or hostname. + Defaults to env var EC2_HOST. + +.PARAMETER Ec2User + SSH username on the EC2 instance. + Defaults to env var EC2_SSH_USER, then "ubuntu". + +.PARAMETER LocalPort + Local port for the SSH tunnel. Defaults to 15432. + +.PARAMETER RemotePort + PostgreSQL port on the EC2 instance. Defaults to 5432. + +.PARAMETER PgUser + PostgreSQL username. Defaults to "root". + +.PARAMETER PgPassword + PostgreSQL password. Defaults to "example". + +.PARAMETER PgDatabase + PostgreSQL database name. Defaults to "postgres". + +.EXAMPLE + .\connect.ps1 -SshKey "~\.ssh\my-key.pem" -Ec2Host "3.14.15.92" -Ec2User "ubuntu" +#> + +param( + [string]$SshKey = $env:EC2_SSH_KEY_PATH, + [string]$Ec2Host = $env:EC2_HOST, + [string]$Ec2User = $(if ($env:EC2_SSH_USER) { $env:EC2_SSH_USER } else { "ubuntu" }), + [int]$LocalPort = 15432, + [int]$RemotePort = 5432, + [string]$PgUser = "root", + [string]$PgPassword = "example", + [string]$PgDatabase = "postgres" +) + +$ErrorActionPreference = "Stop" + +if (-not $SshKey) { + $SshKey = Read-Host "Path to SSH .pem key file" +} +if (-not (Test-Path $SshKey)) { + Write-Error "SSH key not found: $SshKey" + exit 1 +} + +if (-not $Ec2Host) { + $Ec2Host = Read-Host "EC2 host (IP or hostname)" +} + +Write-Host "Opening SSH tunnel: localhost:$LocalPort -> $Ec2Host`:$RemotePort" -ForegroundColor Cyan + +$tunnelProcess = Start-Process -FilePath "ssh" -ArgumentList @( + "-i", $SshKey, + "-L", "${LocalPort}:localhost:${RemotePort}", + "-N", + "-o", "StrictHostKeyChecking=no", + "-o", "ExitOnForwardFailure=yes", + "$Ec2User@$Ec2Host" +) -PassThru -NoNewWindow + +Start-Sleep -Seconds 2 + +if ($tunnelProcess.HasExited) { + Write-Error "SSH tunnel failed to start. Check your key, host, and network." + exit 1 +} + +Write-Host "SSH tunnel running (PID: $($tunnelProcess.Id))" -ForegroundColor Green + +$env:DB_VIEWER_DSN = "postgresql://${PgUser}:${PgPassword}@localhost:${LocalPort}/${PgDatabase}" +Write-Host "DSN: $env:DB_VIEWER_DSN" -ForegroundColor Cyan + +try { + Write-Host "Starting Streamlit viewer..." -ForegroundColor Cyan + streamlit run app.py +} +finally { + Write-Host "Shutting down SSH tunnel (PID: $($tunnelProcess.Id))..." -ForegroundColor Yellow + Stop-Process -Id $tunnelProcess.Id -Force -ErrorAction SilentlyContinue + Write-Host "Done." -ForegroundColor Green +} diff --git a/OpenRAG-DB-viewer/connect.sh b/OpenRAG-DB-viewer/connect.sh new file mode 100644 index 0000000..004cc57 --- /dev/null +++ b/OpenRAG-DB-viewer/connect.sh @@ -0,0 +1,80 @@ +#!/usr/bin/env bash +# +# Launch the DB Viewer with an SSH tunnel to an EC2 PostgreSQL instance. +# +# Usage: +# ./connect.sh # uses env vars or prompts +# ./connect.sh -k ~/.ssh/my-key.pem -h 3.14.15.92 -u ubuntu +# +# Environment variables (all optional, CLI flags take precedence): +# EC2_SSH_KEY_PATH -- path to .pem file +# EC2_HOST -- EC2 public IP or hostname +# EC2_SSH_USER -- SSH username (default: ubuntu) + +set -euo pipefail + +LOCAL_PORT=15432 +REMOTE_PORT=5432 +PG_USER="root" +PG_PASSWORD="example" +PG_DATABASE="postgres" +SSH_KEY="${EC2_SSH_KEY_PATH:-}" +EC2_HOST_VAL="${EC2_HOST:-}" +EC2_USER="${EC2_SSH_USER:-ubuntu}" + +while getopts "k:h:u:p:P:d:" opt; do + case $opt in + k) SSH_KEY="$OPTARG" ;; + h) EC2_HOST_VAL="$OPTARG" ;; + u) EC2_USER="$OPTARG" ;; + p) LOCAL_PORT="$OPTARG" ;; + P) REMOTE_PORT="$OPTARG" ;; + d) PG_DATABASE="$OPTARG" ;; + *) echo "Usage: $0 [-k ssh_key] [-h ec2_host] [-u ec2_user] [-p local_port] [-P remote_port] [-d pg_database]"; exit 1 ;; + esac +done + +if [ -z "$SSH_KEY" ]; then + read -rp "Path to SSH .pem key file: " SSH_KEY +fi +if [ ! -f "$SSH_KEY" ]; then + echo "Error: SSH key not found: $SSH_KEY" >&2 + exit 1 +fi + +if [ -z "$EC2_HOST_VAL" ]; then + read -rp "EC2 host (IP or hostname): " EC2_HOST_VAL +fi + +echo "Opening SSH tunnel: localhost:${LOCAL_PORT} -> ${EC2_HOST_VAL}:${REMOTE_PORT}" + +ssh -i "$SSH_KEY" \ + -L "${LOCAL_PORT}:localhost:${REMOTE_PORT}" \ + -N \ + -o StrictHostKeyChecking=no \ + -o ExitOnForwardFailure=yes \ + "${EC2_USER}@${EC2_HOST_VAL}" & +TUNNEL_PID=$! + +sleep 2 + +if ! kill -0 "$TUNNEL_PID" 2>/dev/null; then + echo "Error: SSH tunnel failed to start. Check your key, host, and network." >&2 + exit 1 +fi + +echo "SSH tunnel running (PID: ${TUNNEL_PID})" + +export DB_VIEWER_DSN="postgresql://${PG_USER}:${PG_PASSWORD}@localhost:${LOCAL_PORT}/${PG_DATABASE}" +echo "DSN: ${DB_VIEWER_DSN}" + +cleanup() { + echo "Shutting down SSH tunnel (PID: ${TUNNEL_PID})..." + kill "$TUNNEL_PID" 2>/dev/null || true + wait "$TUNNEL_PID" 2>/dev/null || true + echo "Done." +} +trap cleanup EXIT INT TERM + +echo "Starting Streamlit viewer..." +streamlit run app.py diff --git a/OpenRAG-DB-viewer/db_utils.py b/OpenRAG-DB-viewer/db_utils.py new file mode 100644 index 0000000..074b68d --- /dev/null +++ b/OpenRAG-DB-viewer/db_utils.py @@ -0,0 +1,388 @@ +"""Database helpers for the Responses DB Viewer. + +Supports two backends: + 1. SQLite -- any table (file-based, read-only) + 2. PostgreSQL -- any table (via psycopg DSN, read-only queries) + +All access is read-only. The module builds parameterised queries and +never mutates the underlying database. +""" + +from __future__ import annotations + +import io +import json +import sqlite3 +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Optional + +import pandas as pd + +# Well-known table schemas for smart defaults (dropdowns, timestamp column). +# Any table not listed here still works -- columns are auto-detected. +KNOWN_TABLES: dict[str, dict[str, Any]] = { + "evaluation_logs": { + "timestamp_col": "timestamp", + "filterable_dropdowns": ["category", "model_name"], + }, + "discord_interaction_logs": { + "timestamp_col": "created_at", + "filterable_dropdowns": ["rag_name", "source", "discord_user_id"], + }, +} + + +# --------------------------------------------------------------------------- +# Unified DB wrapper +# --------------------------------------------------------------------------- + +class DBConn: + """Thin wrapper that normalises SQLite and psycopg connections.""" + + def __init__(self, raw_conn: Any, backend: str, table: str, columns: list[str]) -> None: + self.raw = raw_conn + self.backend = backend + self.table = table + self.columns = columns + self.ph = "?" if backend == "sqlite" else "%s" + + known = KNOWN_TABLES.get(table, {}) + self.timestamp_col = known.get("timestamp_col") or _guess_timestamp_col(columns) + self.filterable_dropdowns: list[str] = [ + c for c in known.get("filterable_dropdowns", []) if c in columns + ] + self.sortable: list[str] = [ + c for c in (["id", self.timestamp_col] + columns) if c in columns + ] + # deduplicate while preserving order + seen: set[str] = set() + deduped: list[str] = [] + for c in self.sortable: + if c not in seen: + seen.add(c) + deduped.append(c) + self.sortable = deduped + + def execute(self, sql: str, params: list[Any] | tuple[Any, ...] = ()) -> list[dict[str, Any]]: + if self.backend == "sqlite": + cur = self.raw.execute(sql, params) + cols = [d[0] for d in cur.description] if cur.description else [] + return [dict(zip(cols, row)) for row in cur.fetchall()] + else: + from psycopg.rows import dict_row + with self.raw.cursor(row_factory=dict_row) as cur: + cur.execute(sql, params) + if cur.description is None: + return [] + return list(cur.fetchall()) + + def execute_scalar(self, sql: str, params: list[Any] | tuple[Any, ...] = ()) -> Any: + if self.backend == "sqlite": + return self.raw.execute(sql, params).fetchone()[0] + else: + with self.raw.cursor() as cur: + cur.execute(sql, params) + return cur.fetchone()[0] + + def close(self) -> None: + self.raw.close() + + +def _guess_timestamp_col(columns: list[str]) -> str: + """Heuristic: pick the first column that looks like a timestamp.""" + for candidate in ("created_at", "timestamp", "updated_at", "date", "ts"): + if candidate in columns: + return candidate + return columns[1] if len(columns) > 1 else columns[0] + + +# --------------------------------------------------------------------------- +# Connection helpers +# --------------------------------------------------------------------------- + +def list_sqlite_tables(db_path: str | Path) -> list[str]: + p = Path(db_path).resolve() + if not p.exists(): + raise FileNotFoundError(f"Database file not found: {p}") + uri = f"file:{p.as_posix()}?mode=ro" + conn = sqlite3.connect(uri, uri=True) + cur = conn.execute( + "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name" + ) + tables = [row[0] for row in cur.fetchall()] + conn.close() + return tables + + +def _sqlite_columns(conn: sqlite3.Connection, table: str) -> list[str]: + cur = conn.execute(f"PRAGMA table_info({table})") + return [row[1] for row in cur.fetchall()] + + +def connect_sqlite(db_path: str | Path, table: str) -> DBConn: + """Open a SQLite DB read-only for a specific table.""" + p = Path(db_path).resolve() + if not p.exists(): + raise FileNotFoundError(f"Database file not found: {p}") + uri = f"file:{p.as_posix()}?mode=ro" + conn = sqlite3.connect(uri, uri=True) + conn.row_factory = sqlite3.Row + columns = _sqlite_columns(conn, table) + if not columns: + conn.close() + raise ValueError(f"Table '{table}' not found or has no columns.") + return DBConn(conn, "sqlite", table, columns) + + +def list_pg_tables(dsn: str) -> list[str]: + import psycopg + conn = psycopg.connect(dsn, autocommit=True) + with conn.cursor() as cur: + cur.execute( + "SELECT table_name FROM information_schema.tables " + "WHERE table_schema = 'public' ORDER BY table_name" + ) + tables = [row[0] for row in cur.fetchall()] + conn.close() + return tables + + +def _pg_columns(conn: Any, table: str) -> list[str]: + with conn.cursor() as cur: + cur.execute( + "SELECT column_name FROM information_schema.columns " + "WHERE table_name = %s ORDER BY ordinal_position", + (table,), + ) + return [row[0] for row in cur.fetchall()] + + +def connect_postgresql(dsn: str, table: str) -> DBConn: + """Open a PostgreSQL connection for a specific table.""" + import psycopg + conn = psycopg.connect(dsn, autocommit=True) + columns = _pg_columns(conn, table) + if not columns: + conn.close() + raise ValueError(f"Table '{table}' not found or has no columns.") + return DBConn(conn, "postgresql", table, columns) + + +# --------------------------------------------------------------------------- +# Dropdown helpers +# --------------------------------------------------------------------------- + +def get_distinct_values(db: DBConn, column: str) -> list[str]: + """Return sorted distinct non-NULL values for a column.""" + if column not in db.columns: + raise ValueError(f"Invalid column '{column}' for table {db.table}") + rows = db.execute( + f"SELECT DISTINCT {column} FROM {db.table} " + f"WHERE {column} IS NOT NULL ORDER BY {column}" + ) + return [str(r[column]) for r in rows] + + +# --------------------------------------------------------------------------- +# Filter dataclass +# --------------------------------------------------------------------------- + +@dataclass +class Filters: + ts_from: Optional[str] = None + ts_to: Optional[str] = None + search_text: Optional[str] = None + search_columns: list[str] | None = None + has_rag: Optional[bool] = None + has_llm: Optional[bool] = None + missing_either: bool = False + min_rag_len: Optional[int] = None + min_llm_len: Optional[int] = None + id_min: Optional[int] = None + id_max: Optional[int] = None + sort_col: str = "" + sort_dir: str = "DESC" + page: int = 1 + page_size: int = 50 + dropdown_filters: dict[str, str | None] = None # type: ignore[assignment] + + def __post_init__(self) -> None: + if self.dropdown_filters is None: + self.dropdown_filters = {} + + +# --------------------------------------------------------------------------- +# Query builder +# --------------------------------------------------------------------------- + +def _where_clause(db: DBConn, f: Filters) -> tuple[str, list[Any]]: + conditions: list[str] = [] + params: list[Any] = [] + ph = db.ph + ts_col = db.timestamp_col + + for col, val in (f.dropdown_filters or {}).items(): + if val and col in db.columns: + conditions.append(f"{col} = {ph}") + params.append(val) + + if f.ts_from and ts_col: + conditions.append(f"{ts_col} >= {ph}") + params.append(f.ts_from) + + if f.ts_to and ts_col: + conditions.append(f"{ts_col} <= {ph}") + params.append(f.ts_to) + + if f.search_text: + like = f"%{f.search_text}%" + text_cols = f.search_columns or ["question", "rag_context", "rag_answer", "llm_answer"] + valid_cols = [c for c in text_cols if c in db.columns] + if valid_cols: + conditions.append("(" + " OR ".join(f"{c} LIKE {ph}" for c in valid_cols) + ")") + params.extend([like] * len(valid_cols)) + + if f.has_rag is True and "rag_answer" in db.columns: + conditions.append("rag_answer IS NOT NULL AND rag_answer != ''") + elif f.has_rag is False and "rag_answer" in db.columns: + conditions.append("(rag_answer IS NULL OR rag_answer = '')") + + if f.has_llm is True and "llm_answer" in db.columns: + conditions.append("llm_answer IS NOT NULL AND llm_answer != ''") + elif f.has_llm is False and "llm_answer" in db.columns: + conditions.append("(llm_answer IS NULL OR llm_answer = '')") + + if f.missing_either: + parts = [] + if "rag_answer" in db.columns: + parts.append("(rag_answer IS NULL OR rag_answer = '')") + if "llm_answer" in db.columns: + parts.append("(llm_answer IS NULL OR llm_answer = '')") + if parts: + conditions.append("(" + " OR ".join(parts) + ")") + + if f.min_rag_len is not None and f.min_rag_len > 0 and "rag_answer" in db.columns: + conditions.append(f"LENGTH(COALESCE(rag_answer, '')) >= {ph}") + params.append(f.min_rag_len) + + if f.min_llm_len is not None and f.min_llm_len > 0 and "llm_answer" in db.columns: + conditions.append(f"LENGTH(COALESCE(llm_answer, '')) >= {ph}") + params.append(f.min_llm_len) + + if f.id_min is not None and "id" in db.columns: + conditions.append(f"id >= {ph}") + params.append(f.id_min) + + if f.id_max is not None and "id" in db.columns: + conditions.append(f"id <= {ph}") + params.append(f.id_max) + + where = "" + if conditions: + where = "WHERE " + " AND ".join(conditions) + return where, params + + +def _resolve_sort(db: DBConn, f: Filters) -> str: + col = f.sort_col if f.sort_col in db.columns else db.timestamp_col + if col not in db.columns: + col = db.columns[0] + direction = "ASC" if f.sort_dir.upper() == "ASC" else "DESC" + return f"{col} {direction}" + + +def fetch_rows(db: DBConn, f: Filters) -> pd.DataFrame: + where, params = _where_clause(db, f) + order = _resolve_sort(db, f) + ph = db.ph + offset = (f.page - 1) * f.page_size + + sql = ( + f"SELECT * FROM {db.table} {where} " + f"ORDER BY {order} " + f"LIMIT {ph} OFFSET {ph}" + ) + params.extend([f.page_size, offset]) + rows = db.execute(sql, params) + if not rows: + return pd.DataFrame(columns=db.columns) + return pd.DataFrame(rows) + + +def fetch_count(db: DBConn, f: Filters) -> int: + where, params = _where_clause(db, f) + sql = f"SELECT COUNT(*) AS cnt FROM {db.table} {where}" + return db.execute_scalar(sql, params) + + +def fetch_row_by_id(db: DBConn, row_id: int) -> dict[str, Any] | None: + ph = db.ph + pk = "id" if "id" in db.columns else db.columns[0] + rows = db.execute( + f"SELECT * FROM {db.table} WHERE {pk} = {ph}", (row_id,) + ) + return rows[0] if rows else None + + +# --------------------------------------------------------------------------- +# Read-only SQL console +# --------------------------------------------------------------------------- + +_FORBIDDEN_PREFIXES = ( + "INSERT", "UPDATE", "DELETE", "DROP", "ALTER", "CREATE", + "REPLACE", "ATTACH", "DETACH", "REINDEX", "VACUUM", "PRAGMA", + "BEGIN", "COMMIT", "ROLLBACK", "SAVEPOINT", "RELEASE", "GRANT", + "TRUNCATE", +) + + +def validate_readonly(sql: str) -> str | None: + stripped = sql.strip().rstrip(";").strip() + if not stripped: + return "Empty query." + first_word = stripped.split()[0].upper() + if first_word == "EXPLAIN": + parts = stripped.split() + if len(parts) < 2: + return "Incomplete EXPLAIN statement." + rest = " ".join(parts[1:]).strip() + if rest.upper().startswith("QUERY PLAN"): + rest = rest[len("QUERY PLAN"):].strip() + if rest.upper().startswith("ANALYZE"): + rest = rest[len("ANALYZE"):].strip() + return validate_readonly(rest) + if first_word not in ("SELECT", "WITH"): + return f"Only SELECT queries are allowed (got {first_word})." + upper_words = set(stripped.upper().split()) + for kw in _FORBIDDEN_PREFIXES: + if kw in upper_words: + return f"Statement contains forbidden keyword: {kw}" + return None + + +def run_readonly_sql(db: DBConn, sql: str) -> pd.DataFrame: + err = validate_readonly(sql) + if err: + raise PermissionError(err) + rows = db.execute(sql) + if not rows: + return pd.DataFrame() + return pd.DataFrame(rows) + + +# --------------------------------------------------------------------------- +# Export helpers +# --------------------------------------------------------------------------- + +def to_csv_bytes(df: pd.DataFrame) -> bytes: + buf = io.StringIO() + df.to_csv(buf, index=False) + return buf.getvalue().encode("utf-8") + + +def to_jsonl_bytes(df: pd.DataFrame) -> bytes: + lines: list[str] = [] + for _, row in df.iterrows(): + lines.append(json.dumps(row.to_dict(), ensure_ascii=False, default=str)) + return "\n".join(lines).encode("utf-8") diff --git a/OpenRAG-DB-viewer/diff_utils.py b/OpenRAG-DB-viewer/diff_utils.py new file mode 100644 index 0000000..0e29268 --- /dev/null +++ b/OpenRAG-DB-viewer/diff_utils.py @@ -0,0 +1,97 @@ +"""Diff and metrics utilities for comparing RAG vs LLM answers.""" + +from __future__ import annotations + +import difflib +import html +import re + + +def tokenize(text: str) -> list[str]: + """Whitespace-tokenize after lowercasing and stripping punctuation.""" + return re.findall(r"\w+", (text or "").lower()) + + +def jaccard_similarity(text_a: str | None, text_b: str | None) -> float: + """Token-level Jaccard similarity between two texts.""" + set_a = set(tokenize(text_a or "")) + set_b = set(tokenize(text_b or "")) + if not set_a and not set_b: + return 1.0 + if not set_a or not set_b: + return 0.0 + return len(set_a & set_b) / len(set_a | set_b) + + +def answer_length(text: str | None) -> int: + return len(text) if text else 0 + + +def token_count(text: str | None) -> int: + return len(tokenize(text or "")) + + +def side_by_side_html(text_a: str | None, text_b: str | None) -> str: + """Return an HTML table showing a side-by-side diff of two texts. + + Additions are highlighted green, deletions red. + """ + a_lines = (text_a or "").splitlines(keepends=True) + b_lines = (text_b or "").splitlines(keepends=True) + differ = difflib.HtmlDiff(wrapcolumn=80) + table = differ.make_table( + a_lines, + b_lines, + fromdesc="RAG Answer", + todesc="LLM Answer", + context=False, + ) + return table + + +def unified_diff_text(text_a: str | None, text_b: str | None) -> str: + """Return a unified diff string.""" + a_lines = (text_a or "").splitlines(keepends=True) + b_lines = (text_b or "").splitlines(keepends=True) + diff = difflib.unified_diff(a_lines, b_lines, fromfile="rag_answer", tofile="llm_answer") + return "".join(diff) + + +def inline_diff_html(text_a: str | None, text_b: str | None) -> tuple[str, str]: + """Return (html_a, html_b) with word-level diff highlights. + + Deleted words in text_a are wrapped in red spans. + Added words in text_b are wrapped in green spans. + """ + words_a = (text_a or "").split() + words_b = (text_b or "").split() + sm = difflib.SequenceMatcher(None, words_a, words_b) + + result_a: list[str] = [] + result_b: list[str] = [] + + for tag, i1, i2, j1, j2 in sm.get_opcodes(): + if tag == "equal": + result_a.extend(html.escape(w) for w in words_a[i1:i2]) + result_b.extend(html.escape(w) for w in words_b[j1:j2]) + elif tag == "replace": + result_a.extend( + f'{html.escape(w)}' + for w in words_a[i1:i2] + ) + result_b.extend( + f'{html.escape(w)}' + for w in words_b[j1:j2] + ) + elif tag == "delete": + result_a.extend( + f'{html.escape(w)}' + for w in words_a[i1:i2] + ) + elif tag == "insert": + result_b.extend( + f'{html.escape(w)}' + for w in words_b[j1:j2] + ) + + return " ".join(result_a), " ".join(result_b) diff --git a/OpenRAG-DB-viewer/requirements.txt b/OpenRAG-DB-viewer/requirements.txt new file mode 100644 index 0000000..6186eda --- /dev/null +++ b/OpenRAG-DB-viewer/requirements.txt @@ -0,0 +1,3 @@ +streamlit>=1.30 +pandas>=2.0 +psycopg[binary]>=3.1 From 82f4c82bd3ac5f588c06abc54c959b27f7c45e84 Mon Sep 17 00:00:00 2001 From: Andrew Sliva Date: Tue, 7 Apr 2026 12:04:25 -0700 Subject: [PATCH 6/6] Overhaul of the DocGPT system to OpenRAG Made-with: Cursor --- .github/labeler.yml | 12 +- .github/workflows/ci.yml | 8 +- .gitignore | 3 + DOCUMENTATION.md | 98 +- OpenRAG-DB-viewer/app.py | 391 +- OpenRAG-DB-viewer/requirements.txt | 1 + systems/docgpt/.env.example | 12 - .../logs/interactions_2026-02-11_120316.csv | 1 - .../logs/interactions_2026-02-11_120634.csv | 10056 ---------------- .../logs/interactions_2026-02-11_120634.jsonl | 3 - .../create-vector-extension.sh | 0 systems/openrag/.env.test | 20 + systems/{docgpt => openrag}/.env.test.example | 4 +- systems/{docgpt => openrag}/.gitignore | 0 systems/{docgpt => openrag}/README.md | 6 +- systems/{docgpt => openrag}/config.yml | 2 +- .../discord_interactions.csv | 0 .../docker-compose.test.yml | 10 +- .../{docgpt => openrag}/docker-compose.yml | 0 systems/{docgpt => openrag}/main.py | 0 .../pandoc-3.9-windows-x86_64.msi | Bin systems/{docgpt => openrag}/pyproject.toml | 2 +- systems/{docgpt => openrag}/run-test-bot.sh | 0 .../src/adapters/__init__.py | 0 .../src/adapters/assistant.py | 0 .../src/adapters/content/__init__.py | 0 .../src/adapters/content/converter.py | 0 .../src/adapters/content/git/__init__.py | 0 .../src/adapters/content/git/code.py | 0 .../src/adapters/content/git/wiki.py | 0 .../src/adapters/content/text_splitter.py | 0 .../src/adapters/content/web.py | 0 .../{docgpt => openrag}/src/app/__init__.py | 0 .../src/app/api/__init__.py | 0 .../src/app/api/create_app.py | 0 .../src/app/api/deps/__init__.py | 0 .../{docgpt => openrag}/src/app/api/health.py | 0 .../src/app/api/runners.py | 0 .../src/app/api/v1/__init__.py | 0 .../src/app/api/v1/endpoints/__init__.py | 0 .../src/app/api/v1/endpoints/assistant.py | 0 .../{docgpt => openrag}/src/app/discord.py | 0 .../{docgpt => openrag}/src/core/__init__.py | 0 .../src/core/containers.py | 2 +- .../src/core/interaction_logger.py | 2 +- .../{docgpt => openrag}/src/core/prompts.py | 2 +- .../src/domain/__init__.py | 0 .../src/domain/assistant.py | 0 .../{docgpt => openrag}/src/domain/auth.py | 0 .../{docgpt => openrag}/src/domain/content.py | 0 .../src/domain/responses/__init__.py | 0 .../src/domain/responses/assistant.py | 0 .../{docgpt => openrag}/src/domain/storage.py | 0 .../src/logging/discord_logger.py | 0 .../{docgpt => openrag}/src/port/__init__.py | 0 .../{docgpt => openrag}/src/port/assistant.py | 0 .../{docgpt => openrag}/src/port/content.py | 0 systems/{docgpt => openrag}/tests/__init__.py | 0 systems/{docgpt => openrag}/tests/conftest.py | 0 .../tests/fixtures/__init__.py | 0 .../tests/test_assistant_metadata.py | 0 .../tests/test_discord_logging.py | 6 +- systems/{docgpt => openrag}/uv.lock | 0 63 files changed, 489 insertions(+), 10152 deletions(-) delete mode 100644 systems/docgpt/.env.example delete mode 100644 systems/docgpt/logs/interactions_2026-02-11_120316.csv delete mode 100644 systems/docgpt/logs/interactions_2026-02-11_120634.csv delete mode 100644 systems/docgpt/logs/interactions_2026-02-11_120634.jsonl rename systems/{docgpt => openrag}/.docker/postgres/docker-entrypoint-initdb.d/create-vector-extension.sh (100%) create mode 100644 systems/openrag/.env.test rename systems/{docgpt => openrag}/.env.test.example (84%) rename systems/{docgpt => openrag}/.gitignore (100%) rename systems/{docgpt => openrag}/README.md (97%) rename systems/{docgpt => openrag}/config.yml (96%) rename systems/{docgpt => openrag}/discord_interactions.csv (100%) rename systems/{docgpt => openrag}/docker-compose.test.yml (72%) rename systems/{docgpt => openrag}/docker-compose.yml (100%) rename systems/{docgpt => openrag}/main.py (100%) rename systems/{docgpt => openrag}/pandoc-3.9-windows-x86_64.msi (100%) rename systems/{docgpt => openrag}/pyproject.toml (98%) rename systems/{docgpt => openrag}/run-test-bot.sh (100%) rename systems/{docgpt => openrag}/src/adapters/__init__.py (100%) rename systems/{docgpt => openrag}/src/adapters/assistant.py (100%) rename systems/{docgpt => openrag}/src/adapters/content/__init__.py (100%) rename systems/{docgpt => openrag}/src/adapters/content/converter.py (100%) rename systems/{docgpt => openrag}/src/adapters/content/git/__init__.py (100%) rename systems/{docgpt => openrag}/src/adapters/content/git/code.py (100%) rename systems/{docgpt => openrag}/src/adapters/content/git/wiki.py (100%) rename systems/{docgpt => openrag}/src/adapters/content/text_splitter.py (100%) rename systems/{docgpt => openrag}/src/adapters/content/web.py (100%) rename systems/{docgpt => openrag}/src/app/__init__.py (100%) rename systems/{docgpt => openrag}/src/app/api/__init__.py (100%) rename systems/{docgpt => openrag}/src/app/api/create_app.py (100%) rename systems/{docgpt => openrag}/src/app/api/deps/__init__.py (100%) rename systems/{docgpt => openrag}/src/app/api/health.py (100%) rename systems/{docgpt => openrag}/src/app/api/runners.py (100%) rename systems/{docgpt => openrag}/src/app/api/v1/__init__.py (100%) rename systems/{docgpt => openrag}/src/app/api/v1/endpoints/__init__.py (100%) rename systems/{docgpt => openrag}/src/app/api/v1/endpoints/assistant.py (100%) rename systems/{docgpt => openrag}/src/app/discord.py (100%) rename systems/{docgpt => openrag}/src/core/__init__.py (100%) rename systems/{docgpt => openrag}/src/core/containers.py (99%) rename systems/{docgpt => openrag}/src/core/interaction_logger.py (99%) rename systems/{docgpt => openrag}/src/core/prompts.py (95%) rename systems/{docgpt => openrag}/src/domain/__init__.py (100%) rename systems/{docgpt => openrag}/src/domain/assistant.py (100%) rename systems/{docgpt => openrag}/src/domain/auth.py (100%) rename systems/{docgpt => openrag}/src/domain/content.py (100%) rename systems/{docgpt => openrag}/src/domain/responses/__init__.py (100%) rename systems/{docgpt => openrag}/src/domain/responses/assistant.py (100%) rename systems/{docgpt => openrag}/src/domain/storage.py (100%) rename systems/{docgpt => openrag}/src/logging/discord_logger.py (100%) rename systems/{docgpt => openrag}/src/port/__init__.py (100%) rename systems/{docgpt => openrag}/src/port/assistant.py (100%) rename systems/{docgpt => openrag}/src/port/content.py (100%) rename systems/{docgpt => openrag}/tests/__init__.py (100%) rename systems/{docgpt => openrag}/tests/conftest.py (100%) rename systems/{docgpt => openrag}/tests/fixtures/__init__.py (100%) rename systems/{docgpt => openrag}/tests/test_assistant_metadata.py (100%) rename systems/{docgpt => openrag}/tests/test_discord_logging.py (89%) rename systems/{docgpt => openrag}/uv.lock (100%) diff --git a/.github/labeler.yml b/.github/labeler.yml index 4c040f1..e69b748 100644 --- a/.github/labeler.yml +++ b/.github/labeler.yml @@ -17,18 +17,18 @@ data-ingestion: - any-glob-to-any-file: - "rag_evaluation/data_ingestion/**" -# DocGPT subproject -docgpt: +# OpenRAG subproject +openrag: - changed-files: - any-glob-to-any-file: - - "systems/docgpt/**" + - "systems/openrag/**" # Tests tests: - changed-files: - any-glob-to-any-file: - "tests/**" - - "systems/docgpt/tests/**" + - "systems/openrag/tests/**" # Documentation documentation: @@ -52,8 +52,8 @@ dependencies: - "pyproject.toml" - "setup.py" - "setup.cfg" - - "systems/docgpt/pyproject.toml" - - "systems/docgpt/uv.lock" + - "systems/openrag/pyproject.toml" + - "systems/openrag/uv.lock" # Configuration config: diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1aaa325..e06a44a 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -84,12 +84,12 @@ jobs: name: coverage-report path: coverage.xml - test-docgpt: - name: Test DocGPT + test-openrag: + name: Test OpenRAG runs-on: ubuntu-latest defaults: run: - working-directory: systems/docgpt + working-directory: systems/openrag steps: - uses: actions/checkout@v4 @@ -104,5 +104,5 @@ jobs: - name: Install dependencies run: uv sync --dev - - name: Run DocGPT tests + - name: Run OpenRAG tests run: uv run pytest tests/ -v --tb=short || echo "No tests found yet" diff --git a/.gitignore b/.gitignore index c412cff..990455e 100644 --- a/.gitignore +++ b/.gitignore @@ -37,6 +37,9 @@ env/ .DS_Store Thumbs.db +# Secrets / keys +*.pem + # Jupyter .ipynb_checkpoints/ diff --git a/DOCUMENTATION.md b/DOCUMENTATION.md index c345fa5..98747fe 100644 --- a/DOCUMENTATION.md +++ b/DOCUMENTATION.md @@ -1,6 +1,6 @@ # In-Depth Documentation -Complete reference for running the RAG Evaluation Framework, the DocGPT RAG system, the test suites, and configuring logging across the entire project. +Complete reference for running the RAG Evaluation Framework, the OpenRAG RAG system, the test suites, and configuring logging across the entire project. --- @@ -9,7 +9,7 @@ Complete reference for running the RAG Evaluation Framework, the DocGPT RAG syst - [1. Prerequisites and Environment Setup](#1-prerequisites-and-environment-setup) - [1.1 System Requirements](#11-system-requirements) - [1.2 Installing the Evaluation Framework](#12-installing-the-evaluation-framework) - - [1.3 Installing DocGPT (The RAG System)](#13-installing-docgpt-the-rag-system) + - [1.3 Installing OpenRAG (The RAG System)](#13-installing-openrag-the-rag-system) - [1.4 Environment Variables Reference](#14-environment-variables-reference) - [2. Running the Evaluator](#2-running-the-evaluator) - [2.1 Overview of Evaluators](#21-overview-of-evaluators) @@ -19,7 +19,7 @@ Complete reference for running the RAG Evaluation Framework, the DocGPT RAG syst - [2.5 Command-Line Evaluation Tools](#25-command-line-evaluation-tools) - [2.6 Data Ingestion and Supported Formats](#26-data-ingestion-and-supported-formats) - [2.7 Interpreting Evaluation Results](#27-interpreting-evaluation-results) -- [3. Running the RAG System (DocGPT)](#3-running-the-rag-system-docgpt) +- [3. Running the RAG System (OpenRAG)](#3-running-the-rag-system-openrag) - [3.1 Architecture Overview](#31-architecture-overview) - [3.2 Infrastructure Setup (Docker)](#32-infrastructure-setup-docker) - [3.3 Ingesting Data into the Vector Store](#33-ingesting-data-into-the-vector-store) @@ -27,14 +27,14 @@ Complete reference for running the RAG Evaluation Framework, the DocGPT RAG syst - [3.5 Running the FastAPI Server](#35-running-the-fastapi-server) - [3.6 Automatic Interaction Logging](#36-automatic-interaction-logging) - [3.7 Configuration Deep Dive](#37-configuration-deep-dive) - - [3.8 Troubleshooting DocGPT](#38-troubleshooting-docgpt) + - [3.8 Troubleshooting OpenRAG](#38-troubleshooting-openrag) - [4. Running the Tests](#4-running-the-tests) - [4.1 Evaluation Framework Tests](#41-evaluation-framework-tests) - - [4.2 DocGPT Tests](#42-docgpt-tests) + - [4.2 OpenRAG Tests](#42-openrag-tests) - [4.3 Continuous Integration (CI)](#43-continuous-integration-ci) - [4.4 Linting and Type Checking](#44-linting-and-type-checking) - [5. Logging](#5-logging) - - [5.1 DocGPT Logging Configuration](#51-docgpt-logging-configuration) + - [5.1 OpenRAG Logging Configuration](#51-openrag-logging-configuration) - [5.2 Changing Log Levels](#52-changing-log-levels) - [5.3 Automatic Interaction Logs (CSV + JSONL)](#53-automatic-interaction-logs-csv--jsonl) - [5.4 Evaluation Framework Logging](#54-evaluation-framework-logging) @@ -49,11 +49,11 @@ Complete reference for running the RAG Evaluation Framework, the DocGPT RAG syst | Component | Requirement | |-----------|-------------| -| Python | 3.10+ (3.11+ for DocGPT) | -| Docker & Docker Compose | Required for DocGPT infrastructure (PostgreSQL + MongoDB) | -| `uv` | Required for DocGPT dependency management ([install guide](https://docs.astral.sh/uv/getting-started/installation/)) | +| Python | 3.10+ (3.11+ for OpenRAG) | +| Docker & Docker Compose | Required for OpenRAG infrastructure (PostgreSQL + MongoDB) | +| `uv` | Required for OpenRAG dependency management ([install guide](https://docs.astral.sh/uv/getting-started/installation/)) | | `pip` | Required for the evaluation framework | -| Pandoc | Required by DocGPT for document conversion (`pypandoc` will attempt auto-install) | +| Pandoc | Required by OpenRAG for document conversion (`pypandoc` will attempt auto-install) | | Git | For cloning the repository | ### 1.2 Installing the Evaluation Framework @@ -84,11 +84,11 @@ pip install -e ".[dev,excel,bibtex]" python -c "from rag_evaluation import RAGEvaluator; print('Evaluation framework OK')" ``` -### 1.3 Installing DocGPT (The RAG System) +### 1.3 Installing OpenRAG (The RAG System) ```bash -# Navigate to the DocGPT directory -cd systems/docgpt +# Navigate to the OpenRAG directory +cd systems/openrag # Install uv if you don't have it # Windows (PowerShell): @@ -117,9 +117,9 @@ cp .env.example .env > **Note:** The basic `RAGEvaluator` (rule-based) requires **no** API keys or external services. -#### DocGPT +#### OpenRAG -Set these in `systems/docgpt/.env`: +Set these in `systems/openrag/.env`: | Variable | Required | Default | Description | |----------|----------|---------|-------------| @@ -612,15 +612,15 @@ All metrics return a dictionary with `score` (float 0.0–1.0) and `details` (di --- -## 3. Running the RAG System (DocGPT) +## 3. Running the RAG System (OpenRAG) -DocGPT is a Retrieval-Augmented Generation system that answers questions about the R `data.table` package. It retrieves relevant documentation from a vector store and uses Google Gemini to generate answers. It runs as either a Discord bot or a FastAPI HTTP server. +OpenRAG is a Retrieval-Augmented Generation system that answers questions about the R `data.table` package. It retrieves relevant documentation from a vector store and uses Google Gemini to generate answers. It runs as either a Discord bot or a FastAPI HTTP server. ### 3.1 Architecture Overview ``` ┌─────────────────────────────────────────────────────────────────┐ -│ DocGPT │ +│ OpenRAG │ │ │ │ ┌──────────┐ ┌──────────────┐ ┌────────────────────┐ │ │ │ Discord │ │ Assistant │ │ Google Gemini │ │ @@ -655,10 +655,10 @@ DocGPT is a Retrieval-Augmented Generation system that answers questions about t ### 3.2 Infrastructure Setup (Docker) -DocGPT requires PostgreSQL (with pgvector) and MongoDB. Both are provided via Docker Compose. +OpenRAG requires PostgreSQL (with pgvector) and MongoDB. Both are provided via Docker Compose. ```bash -cd systems/docgpt +cd systems/openrag # Start infrastructure services in the background docker compose up -d @@ -696,7 +696,7 @@ docker compose down -v # Stop and remove volumes (deletes all data) Before the bot can answer questions, you must ingest the data.table documentation into the vector store. This is a one-time operation (or whenever you want to refresh the data). ```bash -cd systems/docgpt +cd systems/openrag # Make sure Docker services are running docker compose up -d @@ -726,7 +726,7 @@ uv run python main.py --ingest ### 3.4 Running the Discord Bot ```bash -cd systems/docgpt +cd systems/openrag # Make sure Docker services are running docker compose up -d @@ -740,15 +740,15 @@ The bot will log in to Discord and listen for messages. You can interact with it **Console output on startup:** ``` -[2026-02-11 14:31:00] [DEBUG] [src.app.discord]: Logged in as DocGPT#1234 (ID: 123456789) +[2026-02-11 14:31:00] [DEBUG] [src.app.discord]: Logged in as OpenRAG#1234 (ID: 123456789) ``` ### 3.5 Running the FastAPI Server -Instead of the Discord bot, you can run DocGPT as an HTTP API: +Instead of the Discord bot, you can run OpenRAG as an HTTP API: ```bash -cd systems/docgpt +cd systems/openrag # Make sure Docker services are running docker compose up -d @@ -777,7 +777,7 @@ The API response now includes the retrieved context alongside the answer: ### 3.6 Automatic Interaction Logging -Every question asked to DocGPT — whether through the Discord bot, the FastAPI server, or the terminal CLI — is **automatically logged** to structured files on disk. Each interaction records: +Every question asked to OpenRAG — whether through the Discord bot, the FastAPI server, or the terminal CLI — is **automatically logged** to structured files on disk. Each interaction records: - **Timestamp** — when the question was asked - **Session ID** — the Discord thread ID, API session, or `"cli"` @@ -789,7 +789,7 @@ Every question asked to DocGPT — whether through the Discord bot, the FastAPI #### Where the Logs Go -By default, logs are written to `systems/docgpt/logs/`. A pair of files is created each time the bot starts: +By default, logs are written to `systems/openrag/logs/`. A pair of files is created each time the bot starts: ``` logs/ @@ -807,7 +807,7 @@ $env:INTERACTION_LOG_DIR = "C:\my_logs" uv run python main.py # macOS/Linux -INTERACTION_LOG_DIR=/var/log/docgpt uv run python main.py +INTERACTION_LOG_DIR=/var/log/openrag uv run python main.py ``` At startup you will see a confirmation message: @@ -862,7 +862,7 @@ with open("logs/interactions_2026-02-11_143022.jsonl") as f: The fastest way to verify logging is via the FastAPI server: ```bash -cd systems/docgpt +cd systems/openrag docker compose up -d uv run python main.py --ingest # one-time uv run python main.py --api @@ -874,7 +874,7 @@ In another terminal, send a test request: curl -X POST http://localhost:8000/api/v1/assistant/prompt -H "Content-Type: application/json" -d "{\"message\": \"What is data.table?\", \"session_id\": \"test\"}" ``` -Then check `systems/docgpt/logs/` — you will find the CSV and JSONL files with your interaction logged. +Then check `systems/openrag/logs/` — you will find the CSV and JSONL files with your interaction logged. #### Feeding Logs into the Evaluation Framework @@ -886,7 +886,7 @@ from rag_evaluation import RAGEvaluator evaluator = RAGEvaluator() -with open("systems/docgpt/logs/interactions_2026-02-11_143022.jsonl") as f: +with open("systems/openrag/logs/interactions_2026-02-11_143022.jsonl") as f: for line in f: entry = json.loads(line) scores = evaluator.evaluate( @@ -901,7 +901,7 @@ with open("systems/docgpt/logs/interactions_2026-02-11_143022.jsonl") as f: ### 3.7 Configuration Deep Dive -All DocGPT configuration lives in `systems/docgpt/config.yml`. Values use `${ENV_VAR:default}` syntax for environment variable interpolation. +All OpenRAG configuration lives in `systems/openrag/config.yml`. Values use `${ENV_VAR:default}` syntax for environment variable interpolation. **Full configuration structure:** @@ -948,7 +948,7 @@ api: port: ${API_PORT:8000} ``` -### 3.8 Troubleshooting DocGPT +### 3.8 Troubleshooting OpenRAG | Problem | Cause | Solution | |---------|-------|----------| @@ -958,7 +958,7 @@ api: | `pypandoc` errors | Pandoc not installed | Run `pypandoc.ensure_pandoc_installed()` or install Pandoc manually | | Ingestion failures | Binary/malformed files | Non-fatal — check logs for details, other documents still work | | Empty answers from bot | Data not ingested | Run `uv run python main.py --ingest` first | -| `uv: command not found` | uv not installed | Install uv: see [Section 1.3](#13-installing-docgpt-the-rag-system) | +| `uv: command not found` | uv not installed | Install uv: see [Section 1.3](#13-installing-openrag-the-rag-system) | --- @@ -1036,21 +1036,21 @@ The test suite provides reusable fixtures in `tests/conftest.py`: - `sample_data` — A dict with `query`, `context`, `answer`, `ground_truth` (for single evaluation) - `batch_data` — A dict with `queries`, `contexts`, `answers`, `ground_truths` (for batch evaluation) -### 4.2 DocGPT Tests +### 4.2 OpenRAG Tests -DocGPT tests live in `systems/docgpt/tests/`. The test infrastructure is set up (with `conftest.py` and `fixtures/`), but test implementations are still being added. +OpenRAG tests live in `systems/openrag/tests/`. The test infrastructure is set up (with `conftest.py` and `fixtures/`), but test implementations are still being added. ```bash -cd systems/docgpt +cd systems/openrag # Install dev dependencies uv sync --dev -# Run DocGPT tests +# Run OpenRAG tests uv run pytest tests/ -v --tb=short ``` -> **Note:** Since DocGPT tests are still being developed, the CI pipeline uses `|| echo "No tests found yet"` to avoid failing the build. +> **Note:** Since OpenRAG tests are still being developed, the CI pipeline uses `|| echo "No tests found yet"` to avoid failing the build. ### 4.3 Continuous Integration (CI) @@ -1063,7 +1063,7 @@ The GitHub Actions CI pipeline (`.github/workflows/ci.yml`) runs automatically o | `lint` | Runs Ruff linter + formatter check | Python 3.11 | | `type-check` | Runs mypy type checking on `rag_evaluation/` | Python 3.11 | | `test` | Runs pytest with coverage on the evaluation framework | Python 3.10, 3.11, 3.12 | -| `test-docgpt` | Runs pytest on DocGPT tests | Python 3.11 | +| `test-openrag` | Runs pytest on OpenRAG tests | Python 3.11 | **To replicate CI locally:** @@ -1116,9 +1116,9 @@ mypy rag_evaluation/ --ignore-missing-imports ## 5. Logging -### 5.1 DocGPT Logging Configuration +### 5.1 OpenRAG Logging Configuration -DocGPT uses Python's standard `logging` module configured via `config.yml`. The logging dictionary config is applied at startup via `dependency-injector` resource initialization. +OpenRAG uses Python's standard `logging` module configured via `config.yml`. The logging dictionary config is applied at startup via `dependency-injector` resource initialization. **Default log format:** @@ -1140,7 +1140,7 @@ application.core.init_resources() # <-- This applies logging.config.dictConfig( ### 5.2 Changing Log Levels -Set the `LOG_LEVEL` environment variable before starting DocGPT: +Set the `LOG_LEVEL` environment variable before starting OpenRAG: ```bash # Windows (PowerShell) @@ -1171,10 +1171,10 @@ LOG_LEVEL=INFO uv run python main.py ### 5.3 Automatic Interaction Logs (CSV + JSONL) -DocGPT automatically logs every RAG interaction to disk. This is separate from Python's `logging` module — it produces structured data files you can open in Excel or parse with scripts. +OpenRAG automatically logs every RAG interaction to disk. This is separate from Python's `logging` module — it produces structured data files you can open in Excel or parse with scripts. See [Section 3.6 — Automatic Interaction Logging](#36-automatic-interaction-logging) for full details on: -- Where the files are written (`systems/docgpt/logs/` by default) +- Where the files are written (`systems/openrag/logs/` by default) - CSV and JSONL format descriptions - How to change the output directory (`INTERACTION_LOG_DIR`) - How to test the logging @@ -1270,7 +1270,7 @@ python examples/qualitative_eval.py data.csv --output-dir my_logs --verbose ### 5.6 Debugging with LangChain Verbose Mode -DocGPT enables LangChain debug and verbose modes by default in `main.py`: +OpenRAG enables LangChain debug and verbose modes by default in `main.py`: ```python from langchain_core.globals import set_debug, set_verbose @@ -1320,9 +1320,9 @@ ruff check . --fix && ruff format . mypy rag_evaluation/ --ignore-missing-imports -# ── DocGPT RAG System ──────────────────────────────────────────── +# ── OpenRAG RAG System ──────────────────────────────────────────── -cd systems/docgpt +cd systems/openrag # Setup cp .env.example .env # Then edit .env with your keys @@ -1346,7 +1346,7 @@ uv run python main.py --api # Open logs/interactions_*.csv in Excel # Or parse logs/interactions_*.jsonl with Python -# Run DocGPT tests +# Run OpenRAG tests uv run pytest tests/ -v --tb=short # Tear down diff --git a/OpenRAG-DB-viewer/app.py b/OpenRAG-DB-viewer/app.py index ef4e612..247a9e8 100644 --- a/OpenRAG-DB-viewer/app.py +++ b/OpenRAG-DB-viewer/app.py @@ -11,11 +11,16 @@ from datetime import datetime, timedelta import pandas as pd +import plotly.express as px +import plotly.graph_objects as go import streamlit as st import db_utils import diff_utils +# Columns that contain markdown content and should be rendered as such +MARKDOWN_COLUMNS = {"question", "rag_answer", "llm_answer", "rag_context"} + # --------------------------------------------------------------------------- # Page config # --------------------------------------------------------------------------- @@ -212,8 +217,8 @@ # Main area # --------------------------------------------------------------------------- -tab_table, tab_diff, tab_sql = st.tabs( - ["Table View", "Diff View", "SQL Console"] +tab_table, tab_basic, tab_diff, tab_analytics, tab_sql = st.tabs( + ["Table View", "Basic View", "Diff View", "Analytics", "SQL Console"] ) # =========================== TABLE VIEW ================================== @@ -299,7 +304,12 @@ val = row.get(col_name, "") expand = col_name in ("rag_answer", "llm_answer", "question") with st.expander(f"**{col_name}**", expanded=expand): - st.code(str(val) if val is not None else "(NULL)", language=None) + if val is None: + st.caption("(NULL)") + elif col_name in MARKDOWN_COLUMNS: + st.markdown(str(val)) + else: + st.code(str(val), language=None) # Metrics (only if rag/llm columns exist) if "rag_answer" in db.columns and "llm_answer" in db.columns: @@ -345,6 +355,127 @@ f"(at {row.get('feedback_timestamp', 'N/A')})" ) +# =========================== BASIC VIEW ================================== +with tab_basic: + st.subheader("Expanded Row View") + st.caption( + "Each row is displayed as an expandable card with markdown content rendered properly. " + "Ideal for reviewing long responses." + ) + + basic_total = db_utils.fetch_count(db, filters) + basic_total_pages = max(1, math.ceil(basic_total / page_size)) + + col_bpg1, col_bpg2, col_bpg3 = st.columns([1, 2, 1]) + with col_bpg2: + basic_page = st.number_input( + "Page", + min_value=1, + max_value=basic_total_pages, + value=1, + step=1, + key="basic_page", + ) + + basic_filters = db_utils.Filters( + ts_from=filters.ts_from, + ts_to=filters.ts_to, + search_text=filters.search_text, + search_columns=filters.search_columns, + has_rag=filters.has_rag, + has_llm=filters.has_llm, + missing_either=filters.missing_either, + min_rag_len=filters.min_rag_len, + min_llm_len=filters.min_llm_len, + id_min=filters.id_min, + id_max=filters.id_max, + sort_col=filters.sort_col, + sort_dir=filters.sort_dir, + page=basic_page, + page_size=page_size, + dropdown_filters=filters.dropdown_filters, + ) + + st.caption(f"**{basic_total}** rows match · page {basic_page}/{basic_total_pages}") + + basic_df = db_utils.fetch_rows(db, basic_filters) + + if basic_df.empty: + st.info("No rows match your filters.") + else: + pk_col = "id" if "id" in basic_df.columns else basic_df.columns[0] + + for idx, row in basic_df.iterrows(): + row_id = row.get(pk_col, idx) + ts_val = row.get(db.timestamp_col, "") + question_preview = str(row.get("question", ""))[:80] if "question" in row else "" + if len(str(row.get("question", ""))) > 80: + question_preview += "..." + + expander_title = f"**#{row_id}** | {ts_val}" + if question_preview: + expander_title += f" | {question_preview}" + + with st.expander(expander_title, expanded=False): + if "question" in row: + st.markdown("##### Question") + st.markdown(str(row.get("question", ""))) + st.markdown("---") + + col_left, col_right = st.columns(2) + + with col_left: + if "rag_answer" in row: + st.markdown("##### RAG Answer") + rag_text = str(row.get("rag_answer") or "") + if rag_text: + st.markdown(rag_text) + st.caption( + f"{diff_utils.answer_length(rag_text)} chars / " + f"{diff_utils.token_count(rag_text)} tokens" + ) + else: + st.caption("(No RAG answer)") + + with col_right: + if "llm_answer" in row: + st.markdown("##### LLM Answer") + llm_text = str(row.get("llm_answer") or "") + if llm_text: + st.markdown(llm_text) + st.caption( + f"{diff_utils.answer_length(llm_text)} chars / " + f"{diff_utils.token_count(llm_text)} tokens" + ) + else: + st.caption("(No LLM answer)") + + if "rag_answer" in row and "llm_answer" in row: + rag_t = str(row.get("rag_answer") or "") + llm_t = str(row.get("llm_answer") or "") + if rag_t and llm_t: + st.markdown("---") + st.metric( + "Jaccard Similarity", + f"{diff_utils.jaccard_similarity(rag_t, llm_t):.2%}" + ) + + if "rag_context" in row and row.get("rag_context"): + with st.expander("View RAG Context", expanded=False): + st.markdown(str(row.get("rag_context", ""))) + + other_cols = [ + c for c in basic_df.columns + if c not in (pk_col, db.timestamp_col, "question", "rag_answer", + "llm_answer", "rag_context") + ] + if other_cols: + with st.expander("Other Fields", expanded=False): + for col in other_cols: + val = row.get(col) + if val is not None and str(val).strip(): + st.markdown(f"**{col}:** {val}") + # =========================== DIFF VIEW =================================== with tab_diff: if "rag_answer" not in db.columns or "llm_answer" not in db.columns: @@ -408,6 +539,260 @@ else: st.info("No differences found (texts are identical).") +# =========================== ANALYTICS =================================== +with tab_analytics: + st.subheader("Data Analytics") + st.caption("Visualizations and statistics for the current table data.") + + analytics_filters = db_utils.Filters( + ts_from=filters.ts_from, + ts_to=filters.ts_to, + search_text=filters.search_text, + search_columns=filters.search_columns, + has_rag=filters.has_rag, + has_llm=filters.has_llm, + missing_either=filters.missing_either, + min_rag_len=filters.min_rag_len, + min_llm_len=filters.min_llm_len, + id_min=filters.id_min, + id_max=filters.id_max, + sort_col=filters.sort_col, + sort_dir=filters.sort_dir, + page=1, + page_size=10000, + dropdown_filters=filters.dropdown_filters, + ) + + analytics_df = db_utils.fetch_rows(db, analytics_filters) + + if analytics_df.empty: + st.info("No data available for analytics. Adjust your filters.") + else: + st.caption(f"Analyzing **{len(analytics_df)}** rows (max 10,000 for performance)") + + has_rag_col = "rag_answer" in analytics_df.columns + has_llm_col = "llm_answer" in analytics_df.columns + has_ts_col = db.timestamp_col in analytics_df.columns + + if has_rag_col: + analytics_df["rag_answer_len"] = analytics_df["rag_answer"].apply( + lambda x: len(str(x)) if pd.notna(x) else 0 + ) + if has_llm_col: + analytics_df["llm_answer_len"] = analytics_df["llm_answer"].apply( + lambda x: len(str(x)) if pd.notna(x) else 0 + ) + + if has_rag_col and has_llm_col: + analytics_df["jaccard"] = analytics_df.apply( + lambda r: diff_utils.jaccard_similarity( + str(r.get("rag_answer") or ""), + str(r.get("llm_answer") or "") + ), + axis=1 + ) + + st.markdown("### Overview") + overview_cols = st.columns(4) + with overview_cols[0]: + st.metric("Total Rows", len(analytics_df)) + with overview_cols[1]: + if has_rag_col: + non_empty_rag = analytics_df[analytics_df["rag_answer_len"] > 0] + st.metric("With RAG Answer", len(non_empty_rag)) + else: + st.metric("With RAG Answer", "N/A") + with overview_cols[2]: + if has_llm_col: + non_empty_llm = analytics_df[analytics_df["llm_answer_len"] > 0] + st.metric("With LLM Answer", len(non_empty_llm)) + else: + st.metric("With LLM Answer", "N/A") + with overview_cols[3]: + if has_rag_col and has_llm_col: + avg_jaccard = analytics_df["jaccard"].mean() + st.metric("Avg Jaccard", f"{avg_jaccard:.2%}") + else: + st.metric("Avg Jaccard", "N/A") + + st.markdown("---") + + if has_rag_col or has_llm_col: + st.markdown("### Answer Length Distribution") + len_chart_cols = st.columns(2) + + with len_chart_cols[0]: + if has_rag_col: + fig_rag_len = px.histogram( + analytics_df[analytics_df["rag_answer_len"] > 0], + x="rag_answer_len", + nbins=30, + title="RAG Answer Length (chars)", + labels={"rag_answer_len": "Characters"}, + color_discrete_sequence=["#636EFA"] + ) + fig_rag_len.update_layout(showlegend=False, height=300) + st.plotly_chart(fig_rag_len, use_container_width=True) + else: + st.info("No rag_answer column") + + with len_chart_cols[1]: + if has_llm_col: + fig_llm_len = px.histogram( + analytics_df[analytics_df["llm_answer_len"] > 0], + x="llm_answer_len", + nbins=30, + title="LLM Answer Length (chars)", + labels={"llm_answer_len": "Characters"}, + color_discrete_sequence=["#EF553B"] + ) + fig_llm_len.update_layout(showlegend=False, height=300) + st.plotly_chart(fig_llm_len, use_container_width=True) + else: + st.info("No llm_answer column") + + if has_rag_col and has_llm_col: + st.markdown("### RAG vs LLM Comparison") + comparison_cols = st.columns(2) + + with comparison_cols[0]: + fig_scatter = px.scatter( + analytics_df[ + (analytics_df["rag_answer_len"] > 0) & + (analytics_df["llm_answer_len"] > 0) + ], + x="rag_answer_len", + y="llm_answer_len", + title="Answer Length: RAG vs LLM", + labels={ + "rag_answer_len": "RAG Length (chars)", + "llm_answer_len": "LLM Length (chars)" + }, + opacity=0.6 + ) + fig_scatter.add_trace( + go.Scatter( + x=[0, analytics_df["rag_answer_len"].max()], + y=[0, analytics_df["rag_answer_len"].max()], + mode="lines", + name="Equal Length", + line={"dash": "dash", "color": "gray"} + ) + ) + fig_scatter.update_layout(height=350) + st.plotly_chart(fig_scatter, use_container_width=True) + + with comparison_cols[1]: + fig_jaccard = px.histogram( + analytics_df, + x="jaccard", + nbins=20, + title="Jaccard Similarity Distribution", + labels={"jaccard": "Jaccard Similarity"}, + color_discrete_sequence=["#00CC96"] + ) + fig_jaccard.update_layout( + showlegend=False, + height=350, + xaxis={"tickformat": ".0%"} + ) + st.plotly_chart(fig_jaccard, use_container_width=True) + + if has_ts_col: + st.markdown("### Interactions Over Time") + try: + analytics_df["ts_parsed"] = pd.to_datetime( + analytics_df[db.timestamp_col], errors="coerce" + ) + ts_valid = analytics_df[analytics_df["ts_parsed"].notna()].copy() + + if not ts_valid.empty: + ts_valid["date"] = ts_valid["ts_parsed"].dt.date + daily_counts = ts_valid.groupby("date").size().reset_index(name="count") + + fig_time = px.line( + daily_counts, + x="date", + y="count", + title="Daily Interaction Count", + labels={"date": "Date", "count": "Interactions"}, + markers=True + ) + fig_time.update_layout(height=300) + st.plotly_chart(fig_time, use_container_width=True) + else: + st.info("Could not parse timestamp column for time series.") + except Exception: + st.info("Could not parse timestamp column for time series.") + + categorical_cols = [ + c for c in ["rag_name", "category", "model_name", "source"] + if c in analytics_df.columns + ] + + if categorical_cols: + st.markdown("### Category Breakdowns") + cat_cols_display = st.columns(min(len(categorical_cols), 3)) + + for i, cat_col in enumerate(categorical_cols[:3]): + with cat_cols_display[i]: + value_counts = analytics_df[cat_col].value_counts().head(10) + if not value_counts.empty: + fig_bar = px.bar( + x=value_counts.index.astype(str), + y=value_counts.values, + title=f"Top {cat_col} Values", + labels={"x": cat_col, "y": "Count"} + ) + fig_bar.update_layout( + showlegend=False, + height=300, + xaxis_tickangle=-45 + ) + st.plotly_chart(fig_bar, use_container_width=True) + + st.markdown("### Summary Statistics") + if has_rag_col or has_llm_col: + stats_data = [] + if has_rag_col: + rag_lens = analytics_df[analytics_df["rag_answer_len"] > 0]["rag_answer_len"] + if not rag_lens.empty: + stats_data.append({ + "Metric": "RAG Answer Length", + "Mean": f"{rag_lens.mean():.0f}", + "Median": f"{rag_lens.median():.0f}", + "Min": f"{rag_lens.min():.0f}", + "Max": f"{rag_lens.max():.0f}", + "Std Dev": f"{rag_lens.std():.0f}" + }) + if has_llm_col: + llm_lens = analytics_df[analytics_df["llm_answer_len"] > 0]["llm_answer_len"] + if not llm_lens.empty: + stats_data.append({ + "Metric": "LLM Answer Length", + "Mean": f"{llm_lens.mean():.0f}", + "Median": f"{llm_lens.median():.0f}", + "Min": f"{llm_lens.min():.0f}", + "Max": f"{llm_lens.max():.0f}", + "Std Dev": f"{llm_lens.std():.0f}" + }) + if has_rag_col and has_llm_col: + jaccard_vals = analytics_df["jaccard"] + stats_data.append({ + "Metric": "Jaccard Similarity", + "Mean": f"{jaccard_vals.mean():.2%}", + "Median": f"{jaccard_vals.median():.2%}", + "Min": f"{jaccard_vals.min():.2%}", + "Max": f"{jaccard_vals.max():.2%}", + "Std Dev": f"{jaccard_vals.std():.2%}" + }) + + if stats_data: + stats_df = pd.DataFrame(stats_data) + st.dataframe(stats_df, use_container_width=True, hide_index=True) + else: + st.info("No answer columns available for statistics.") + # =========================== SQL CONSOLE ================================= with tab_sql: st.subheader("Read-only SQL Console") diff --git a/OpenRAG-DB-viewer/requirements.txt b/OpenRAG-DB-viewer/requirements.txt index 6186eda..a4b4224 100644 --- a/OpenRAG-DB-viewer/requirements.txt +++ b/OpenRAG-DB-viewer/requirements.txt @@ -1,3 +1,4 @@ streamlit>=1.30 pandas>=2.0 psycopg[binary]>=3.1 +plotly>=5.18 diff --git a/systems/docgpt/.env.example b/systems/docgpt/.env.example deleted file mode 100644 index 7d77f54..0000000 --- a/systems/docgpt/.env.example +++ /dev/null @@ -1,12 +0,0 @@ -# Gemini API key (or set GOOGLE_API_KEY) -AI_GEMINI_APIKEY= - -# Discord bot token -APP_DISCORD_TOKEN= - -# PostgreSQL for vector storage (must match docker-compose or your Postgres) -# Format: postgresql+psycopg://USER:PASSWORD@HOST:PORT/DATABASE -STORAGE_VECTOR_URL=postgresql+psycopg://root:example@localhost:5432/postgres - -# MongoDB for chat memory -STORAGE_MEMORY_URL=mongodb://root:example@localhost:27017 diff --git a/systems/docgpt/logs/interactions_2026-02-11_120316.csv b/systems/docgpt/logs/interactions_2026-02-11_120316.csv deleted file mode 100644 index c92d4d0..0000000 --- a/systems/docgpt/logs/interactions_2026-02-11_120316.csv +++ /dev/null @@ -1 +0,0 @@ -timestamp,session_id,question,retrieved_context,answer,source_count diff --git a/systems/docgpt/logs/interactions_2026-02-11_120634.csv b/systems/docgpt/logs/interactions_2026-02-11_120634.csv deleted file mode 100644 index 0546aee..0000000 --- a/systems/docgpt/logs/interactions_2026-02-11_120634.csv +++ /dev/null @@ -1,10056 +0,0 @@ -timestamp,session_id,question,retrieved_context,answer,source_count -2026-02-11T12:07:22,1471220254439899209,no,"20090925 AYE 26.8 26.98 26.64 26.71 22841 20090928 AYE 26.8 27.14 26.71 27.01 11299 20090929 AYE 26.97 27.18 26.72 26.94 21074 20090930 AYE 26.91 27.04 26.32 26.52 21318 20091001 AYE 26.41 26.48 25.61 25.63 22455 20091002 AYE 25.36 25.6 25.07 25.4 17742 20091005 AYE 25.41 25.99 25.18 25.88 26956 20091006 AYE 25.9 26.25 25.74 26.12 20282 20091007 AYE 26.02 26.13 25.74 25.97 12686 20091008 AYE 26.11 26.13 25.81 25.86 16599 20091009 AYE 25.89 26.05 25.72 25.84 23147 20091012 AYE 26.03 26.24 25.82 26.02 11314 20091013 AYE 25.95 26.04 25.55 25.58 17254 20091014 AYE 25.79 26 25.4 25.66 19319 20091015 AYE 25.65 26.11 25.65 26.01 26979 20091016 AYE 25.85 26.6 25.72 26.43 27533 20091019 AYE 26.46 26.91 26.21 26.75 17019 20091020 AYE 26.81 26.83 26.44 26.78 17225 20091021 AYE 26.78 27.15 26.67 26.67 18620 20091022 AYE 26.59 26.65 26.3 26.52 22360 20091023 AYE 26.73 27.03 26.11 26.3 19962 20091026 AYE 26.31 26.79 25.71 25.82 16248 20091027 AYE 25.8 25.98 25.32 25.35 18698 20091028 AYE 25.28 25.49 24.95 25.02 29643 20091105 AYE 22.54 22.99 22.54 22.99 24919 20091106 AYE 22.9 23.03 22.55 22.68 22038 20091109 AYE 22.88 23.22 22.71 23.22 15980 20091110 AYE 23.11 23.31 22.96 23.06 18702 20091111 AYE 22.52 23.06 22.48 22.76 41960 20091112 AYE 22.78 22.86 22.36 22.43 17049 20091113 AYE 22.44 22.57 22.16 22.4 26759 20091116 AYE 22.43 22.73 22.42 22.68 17993 20091117 AYE 22.67 22.76 22.47 22.6 15328 20091118 AYE 22.56 22.78 22.499 22.6 19040 20091119 AYE 22.46 22.55 22.01 22.1 29953 20091120 AYE 22.05 22.2 21.94 22.09 26083 20091123 AYE 22.44 22.58 22.13 22.25 15668 20091124 AYE 22.3 22.33 21.99 22.26 19701 20091125 AYE 22.24 22.45 22.21 22.34 13752 20091127 AYE 21.96 22.255 21.85 21.95 6768 20091130 AYE 21.86 22.1 21.84 21.98 24152 20091201 AYE 22.14 22.52 22.11 22.3 17228 20091202 AYE 22.31 22.7 22.3 22.65 17861 20091203 AYE 22.68 22.92 22.43 22.69 17993 20091204 AYE 22.84 23.0497 22.28 22.65 20840 20091207 AYE 22.55 23.01 22.52 22.7 15095 20091208 AYE 22.65 22.71 22.33 22.54 14779 20091209 AYE 22.57 22.62 22.125 22.31 15036 20091210 AYE 22.26 22.71 22.26 22.62 17616 20091211 AYE 22.75 23.01 22.55 22.97 24376 20091214 AYE 23.04 23.36 23 23.29 19258 20091215 AYE 23.25 23.41 23.13 23.38 16977 20091216 AYE 23 23.38 22.94 23.15 33733 20091217 AYE 23.12 23.65 22.9 23.62 36202 20091218 AYE 23.71 23.91 23.46 23.55 20561 20091221 AYE 23.58 24.3 23.55 24.19 24204 20091222 AYE 24.21 24.33 23.86 24.04 12611 20091223 AYE 24.15 24.25 23.88 24.07 8722 20091224 AYE 24.04 24.29 24.03 24.11 4207 20091228 AYE 24.22 24.34 24.05 24.22 11425 20091229 AYE 24.22 24.5 24.13 24.36 18247 20091230 AYE 24.2 24.32 23.79 23.83 20648 20091231 AYE 23.86 23.9 23.45 23.48 10208 20100104 AYE 23.58 23.66 23.34 23.52 27198 20100105 AYE 23.51 23.5499 23.07 23.13 24302 20100106 AYE 23.17 23.71 23 23.66 31455 20100107 AYE 23.58 23.58 23.2 23.21 21737 20100108 AYE 23.12 23.18 22.95 22.99 15612 20100111 AYE 23.04 23.1 22.78 23.04 25592 20100112 AYE 22.97 23.12 22.7 22.95 19785 20100113 AYE 23.05 23.08 22.75 22.95 14783 20100114 AYE 22.95 22.97 22.71 22.72 12353 20100115 AYE 22.62 22.7 22.35 22.57 22606 20100119 AYE 22.4 22.72 22.3 22.72 24003 20100120 AYE 22.64 22.75 22.46 22.75 22720 20100121 AYE 22.74 23 22.28 22.34 36671 20100122 AYE 22.31 22.36 21.74 21.77 42210 20100125 AYE 21.95 22.07 21.76 21.92 14996 20100126 AYE 21.91 21.94 21.53 21.65 17558 20100127 AYE 21.65 21.65 21.08 21.26 26624 20100128 AYE 21.26 21.36 20.86 21.09 24743 20100129 AYE 21.26 21.31 20.91 20.95 20751 20100201 AYE 21.13 21.13 20.8 20.95 18613 20100202 AYE 20.94 21.0501 20.75 20.9 31327 20100203 AYE 20.89 21.1 20.71 21.01 26580 20100204 AYE 20.91 21.03 20.43 20.49 50574 20100205 AYE 20.53 21.195 20.4 20.99 61650 20100208 AYE 21.11 21.2 20.82 20.89 32660 20100209 AYE 21.07 21.61 21.02 21.18 32168 20100210 AYE 21.18 21.19 20.82 21.02 23162 20100211 AYE 22.78 23.77 22.78 23.55 281235 20100212 AYE 23.49 23.56 22.54 22.72 135049 20100216 AYE 23.05 23.22 22.6 22.84 54802 20100217 AYE 22.87 22.9965 22.49 22.59 36250 - ---- - -9.27 9.31 186575 20091217 JAVA 9.3 9.33 9.21 9.29 334541 20091218 JAVA 9.32 9.35 9.32 9.33 116914 20091221 JAVA 9.33 9.36 9.33 9.35 137242 20091222 JAVA 9.35 9.36 9.32 9.33 91109 20091223 JAVA 9.33 9.36 9.33 9.36 110515 20091224 JAVA 9.36 9.3605 9.34 9.35 23676 20091228 JAVA 9.36 9.38 9.35 9.38 53897 20091229 JAVA 9.38 9.38 9.36 9.37 34344 20091230 JAVA 9.37 9.38 9.36 9.38 43685 20091231 JAVA 9.37 9.37 9.33 9.37 62886 20100104 JAVA 9.37 9.4 9.36 9.38 70839 20100105 JAVA 9.38 9.4 9.38 9.39 41146 20100106 JAVA 9.39 9.39 9.36 9.36 33112 20100107 JAVA 9.37 9.4 9.36 9.4 49974 20100108 JAVA 9.37 9.39 9.37 9.38 29907 20100111 JAVA 9.39 9.41 9.38 9.41 51734 20100112 JAVA 9.41 9.43 9.39 9.42 89459 20100113 JAVA 9.4 9.42 9.4 9.42 54463 20100114 JAVA 9.41 9.43 9.4 9.42 51620 20100115 JAVA 9.43 9.43 9.37 9.42 250474 20100119 JAVA 9.39 9.42 9.39 9.41 70431 20100120 JAVA 9.41 9.45 9.41 9.43 54027 20100121 JAVA 9.47 9.48 9.47 9.47 126642 20100122 JAVA 9.47 9.48 9.46 9.46 90326 20100125 JAVA 9.475 9.48 9.47 9.48 36967 20100126 JAVA 9.47 9.49 9.46 9.49 118044 20090821 JBL 10.23 10.78 9.99 10.71 48010 20090824 JBL 10.77 10.97 10.51 10.56 35844 20090825 JBL 10.72 11.09 10.6 10.8 26991 20090826 JBL 10.62 10.89 10.52 10.63 17269 20090827 JBL 10.7 10.81 10.49 10.81 19949 20090828 JBL 10.99 11.24 10.96 11.16 28957 20090831 JBL 11.14 11.14 10.81 10.95 30076 20090901 JBL 10.77 11.28 10.62 10.95 56248 20090902 JBL 10.92 10.93 10.41 10.56 48428 20090903 JBL 10.57 10.73 10.505 10.72 26144 20090904 JBL 10.74 11.09 10.58 11.08 27434 20090909 JBL 11.11 12 11.03 11.83 44339 20090910 JBL 11.83 11.96 11.7 11.78 28381 20090911 JBL 11.8 11.88 11.55 11.77 17501 20090914 JBL 11.67 11.91 11.45 11.91 26301 20090915 JBL 11.89 12.24 11.84 11.89 37650 20090916 JBL 12 12.48 12 12.2 51955 20090917 JBL 12.16 12.56 11.91 11.91 39134 20090918 JBL 12.05 12.41 11.9 12.41 92549 20090921 JBL 12.3 12.46 12.17 12.4 35190 20090922 JBL 12.47 12.4901 12.33 12.34 27170 20090923 JBL 12.35 13.18 12.35 12.69 55449 20090924 JBL 12.92 12.92 12.51 12.53 53959 20090925 JBL 12.39 12.41 11.54 11.87 66130 20090928 JBL 11.97 12.52 11.93 12.38 33261 20090929 JBL 12.47 12.53 12.07 12.28 70816 20090930 JBL 13.04 13.55 12.93 13.41 145041 20091001 JBL 13.41 13.46 12.89 12.89 81367 20091002 JBL 12.51 13.03 12.51 12.94 61661 20091005 JBL 13.06 13.68 12.98 13.6 66526 20091006 JBL 13.7 14.06 13.64 13.88 71935 20091007 JBL 13.82 13.97 13.64 13.92 43895 20091008 JBL 14.02 14.3 13.82 13.95 53530 20091009 JBL 14.03 14.38 13.9 14.35 23601 20091012 JBL 14.5 14.69 14.41 14.56 32170 20091013 JBL 14.57 14.73 14.36 14.64 47996 20091014 JBL 14.9 15.42 14.77 15.38 59031 20091015 JBL 15.26 15.28 15 15.2 28201 20091016 JBL 15.07 15.17 14.58 14.78 40785 20091019 JBL 14.81 15.34 14.81 15.18 36457 20091020 JBL 15.33 15.33 14.87 15.12 29727 20091021 JBL 14.97 15.45 14.9 14.96 33329 20091022 JBL 14.86 15.0076 14.57 14.88 29194 20091023 JBL 15.05 15.21 14.81 14.96 37697 20091026 JBL 15.02 15.4 14.94 15 76063 20091027 JBL 15.01 15.29 14.6 14.65 53327 20091028 JBL 14.52 14.65 13.66 13.69 56446 20091105 JBL 13.85 14.36 13.77 14.24 45503 20091106 JBL 14.05 14.58 14 14.29 29990 20091109 JBL 14.55 14.91 14.47 14.83 27931 20091110 JBL 14.74 14.99 14.5 14.77 26049 20091111 JBL 14.87 15 14.65 14.7 34739 20091112 JBL 14.69 14.71 14.365 14.45 26433 20091113 JBL 14.48 14.585 14.32 14.48 20148 20091116 JBL 14.58 14.58 14.33 14.52 40342 20091117 JBL 14.41 14.51 14.2817 14.42 23841 20091118 JBL 14.4 14.5 14.18 14.23 20795 20091119 JBL 14.11 14.11 13.43 13.75 30151 20091120 JBL 13.6 13.77 13.5 13.63 22447 20091123 JBL 13.92 14.1 13.79 13.93 21814 20091124 JBL 13.87 13.93 13.33 13.37 30353 20091125 JBL 13.39 13.67 13.34 13.53 16662 20091127 JBL 13.07 13.51 12.77 13.34 12380 20091130 JBL 13.3 13.36 13.01 13.31 26205 20091201 JBL 13.4 13.64 13.24 13.27 29217 20091202 JBL 13.09 13.23 13 13.1 35237 20091203 JBL 13.11 13.34 12.81 12.86 42815 20091204 JBL 13.12 13.35 12.81 12.94 48359 20091207 JBL 12.95 13.39 12.93 13.25 30656 20091208 JBL 13.16 - ---- - -41.35 41.555 41.26 41.5 17212 20100405 STJ 41.56 41.83 41.29 41.51 18442 20100406 STJ 41.35 41.59 41.1 41.22 17358 20100407 STJ 41 41.06 40.61 40.81 30351 20100408 STJ 40.84 40.94 40.51 40.79 21837 20100409 STJ 40.76 41.37 40.59 41.24 17293 20100412 STJ 41.96 42.87 41.96 42.46 50159 20100413 STJ 42.32 42.4 41.9 42.31 28456 20100414 STJ 42.23 42.4 42.05 42.24 21834 20100415 STJ 42.14 42.29 41.78 41.94 26087 20100416 STJ 41 41.85 40.75 40.88 67446 20100419 STJ 40.87 41.15 40.79 40.9 34594 20100420 STJ 41.05 41.23 40.88 41 43689 20100421 STJ 42 42.18 41.33 41.75 66452 20100422 STJ 41.84 42.5 41.26 41.67 46986 20100423 STJ 41.59 41.75 40.56 40.9 51666 20100426 STJ 40.96 41.04 40.17 40.19 23978 20100427 STJ 40 40.74 39.97 40.42 43844 20100428 STJ 40.43 40.8 40.08 40.59 26981 20100429 STJ 40.67 41.14 40.57 40.63 23693 20100430 STJ 40.71 41 40.38 40.82 24568 20100503 STJ 40.74 40.83 40.17 40.74 19327 20100504 STJ 40.33 40.42 39.7 39.94 17440 20100505 STJ 39.81 39.81 38.46 38.64 65739 20100506 STJ 38.64 39 34 37.75 66586 20100507 STJ 37.87 37.87 36.4 37.15 70804 20100510 STJ 38.07 38.67 37.97 38.24 29237 20100511 STJ 38.87 39 38.3 38.4 30422 20100512 STJ 38.36 39.23 38.21 39.19 30935 20100513 STJ 40.7 40.7 39.2 39.31 27265 20100514 STJ 39.24 39.31 38.43 38.59 25705 20100517 STJ 38.75 39.04 38.14 38.68 23317 20100518 STJ 38.88 39.14 38.36 38.46 20672 20100519 STJ 38.29 38.57 38.03 38.4 23947 20100520 STJ 37.61 37.97 37.31 37.4 31896 20100521 STJ 36.98 37.75 36.68 37.18 51571 20100524 STJ 36.94 37.695 36.94 37.14 26080 20100525 STJ 36.52 37.06 36.32 37.05 33854 20100526 STJ 37.11 37.45 36.74 36.84 25998 20100527 STJ 37.27 37.77 37.15 37.74 22422 20100528 STJ 37.65 37.7 37.21 37.34 17190 20100601 STJ 37.12 37.39 36.4 36.45 27639 20100602 STJ 36.57 37.44 36.35 37.44 24321 20100603 STJ 37.45 38.15 37.38 37.99 23475 20100604 STJ 37.4 37.53 36.4 36.55 35699 20100607 STJ 36.63 36.63 36.24 36.24 29664 20100608 STJ 36.09 36.53 36.07 36.49 29462 20100609 STJ 36.98 36.98 35.99 36.07 32781 20100610 STJ 36.46 36.77 36.23 36.56 43307 20100611 STJ 36.25 36.88 35.66 36.88 19527 20100614 STJ 37 37.42 36.91 36.91 15209 20100615 STJ 37.25 37.66 37.03 37.66 13934 20100616 STJ 37.22 37.79 37.22 37.77 12097 20100617 STJ 37.98 37.98 37.58 37.79 15270 20100618 STJ 37.84 37.98 37.39 37.39 30448 20100621 STJ 37.94 38.11 37.4 37.48 19064 20100622 STJ 37.56 37.62 36.74 36.78 26234 20100623 STJ 36.76 36.76 36.14 36.39 26457 20100624 STJ 36.15 37 35.99 36.66 35199 20100625 STJ 36.78 37.155 36.68 37.06 30454 20100628 STJ 37.1 37.76 37.06 37.5 29547 20100629 STJ 37.16 37.16 36.39 36.55 29989 20100630 STJ 36.42 36.62 36.0519 36.09 27988 20100701 STJ 36.02 36.02 34.51 35.28 55207 20100702 STJ 35.37 35.77 35.29 35.48 17310 20100706 STJ 35.65 35.94 35.24 35.59 18798 20100707 STJ 35.53 36.45 35.45 36.4 43021 20100708 STJ 36.58 36.82 36.23 36.45 27655 20100709 STJ 36.58 36.86 36.5 36.7 20206 20100712 STJ 36.62 36.76 36.44 36.65 15205 20100713 STJ 36.79 37.25 36.74 37.17 29449 20100714 STJ 37 37.24 36.81 36.99 24287 20100715 STJ 36.85 37.15 36.37 36.76 28677 20100716 STJ 36.54 36.79 35.61 35.68 32226 20100719 STJ 35.74 35.96 35.52 35.76 21183 20100720 STJ 35.47 35.675 34.98 35.64 29579 20100721 STJ 35.73 35.73 34.25 34.62 54957 20100722 STJ 36.53 37.49 35.3 35.39 65515 20100723 STJ 35.43 36.97 35.43 36.81 57473 20100726 STJ 36.78 37.44 36.71 37.21 32998 20100727 STJ 37.35 37.51 36.87 37.5 33437 20100728 STJ 37.42 37.46 36.53 36.54 25251 20100729 STJ 36.76 36.97 35.99 36.35 34330 20100730 STJ 35.95 36.98 35.6 36.77 22168 20100802 STJ 37.2 37.52 37.13 37.22 23055 20100803 STJ 37.13 37.88 37.12 37.69 32904 20100804 STJ 37.67 38.26 37.64 38.2 18076 20100805 STJ 38.17 38.32 37.76 38.31 19988 20100806 STJ 38.03 38.54 37.8 38.51 19684 20100809 STJ 38.49 38.56 37.86 38.53 20717 20100810 STJ 38.22 38.69 37.88 38.46 18865 20100811 STJ 38.03 38.05 37.18 37.28 17932 20100812 STJ 37.05 37.52 36.8 37.44 14716 20100813 STJ 37.3 37.52 37.21 37.23 11866 20100816 STJ 37.06 37.15 36.8 36.9 - ---- - -see .ci/README.md - ---- - -14.03 13.75 14 24969 20100316 JNS 14.05 14.1 13.87 14 14858 20100317 JNS 14.07 14.4 14.07 14.35 26312 20100318 JNS 14.26 14.4 14.23 14.37 16775 20100319 JNS 14.31 14.41 14.01 14.02 24438 20100322 JNS 13.92 14.15 13.79 14.15 15669 20100323 JNS 14.21 14.37 13.99 14.33 14384 20100324 JNS 14.22 14.36 13.95 14.13 16722 20100325 JNS 14.25 14.83 14.21 14.43 39371 20100326 JNS 14.44 14.63 14.12 14.27 15340 20100329 JNS 14.38 14.64 14.35 14.54 21047 20100330 JNS 14.52 14.6 14.26 14.45 12239 20100331 JNS 14.31 14.51 14.21 14.29 17425 20100401 JNS 14.77 15.07 14.63 14.7 33950 20100405 JNS 14.78 15.03 14.74 14.98 18832 20100406 JNS 14.97 15.33 14.92 15.3 23833 20100407 JNS 15.23 15.35 14.82 14.9 33265 20100408 JNS 14.88 14.91 14.61 14.68 32790 20100409 JNS 14.7 14.8 14.52 14.59 37829 20100412 JNS 14.65 14.77 14.59 14.67 13976 20100413 JNS 14.645 14.9 14.57 14.86 13512 20100414 JNS 14.91 15.46 14.91 15.45 25093 20100415 JNS 15.43 15.72 15.25 15.72 27257 20100416 JNS 15.61 15.67 14.84 15.09 52990 20100419 JNS 14.5 15.22 14.5 14.83 55265 20100420 JNS 14.98 15.505 14.83 15.38 36271 20100421 JNS 15.41 15.49 14.935 15.17 34089 20100422 JNS 14.4 14.5 13.95 14.14 106707 20100423 JNS 14 14.45 14 14.44 59267 20100426 JNS 14.36 14.47 14.22 14.27 53392 20100427 JNS 14.11 14.21 13.66 13.66 64682 20100428 JNS 13.86 14.04 13.52 13.74 43924 20100429 JNS 13.92 14.6 13.92 14.56 38645 20100430 JNS 14.54 14.65 14.08 14.08 34042 20100503 JNS 14.23 14.4 14.07 14.32 25927 20100504 JNS 14.11 14.12 13.38 13.49 51938 20100505 JNS 13.27 13.68 13.03 13.2 24317 20100506 JNS 13.11 13.42 11.6 12.5 65648 20100507 JNS 12.48 12.6 11.82 12.11 70227 20100510 JNS 12.92 13.13 12.33 12.98 34186 20100511 JNS 12.68 13.02 12.56 12.83 32801 20100512 JNS 12.83 13.21 12.7 13.18 32567 20100513 JNS 13.11 13.26 12.79 12.8 28155 20100514 JNS 12.64 12.64 12.1 12.31 40907 20100517 JNS 12.32 12.55 11.66 12.34 63630 20100518 JNS 12.51 12.72 11.75 11.87 47004 20100519 JNS 11.78 11.99 11.43 11.78 51617 20100520 JNS 11.46 11.57 11.02 11.02 57647 20100521 JNS 10.78 11.37 10.51 11.36 66159 20100524 JNS 10.98 11.12 10.51 10.51 69680 20100525 JNS 10.22 10.81 10 10.79 68711 20100526 JNS 10.84 11.02 10.23 10.28 65956 20100527 JNS 10.58 10.81 10.36 10.8 52828 20100528 JNS 10.8 10.82 10.52 10.66 37594 20100601 JNS 10.48 10.57 10.07 10.08 32684 20100602 JNS 10.21 10.45 9.93 10.45 32522 20100603 JNS 10.59 10.59 10.27 10.45 37667 20100604 JNS 10.15 10.34 9.87 9.95 59422 20100607 JNS 9.99 10.12 9.62 9.68 41755 20100608 JNS 9.73 9.85 9.37 9.76 39952 20100609 JNS 9.86 9.94 9.55 9.61 48196 20100610 JNS 9.78 10.45 9.72 10.44 70352 20100611 JNS 10.23 10.65 10.2 10.6 38109 20100614 JNS 10.73 10.745 10.39 10.39 31324 20100615 JNS 10.54 10.56 10.39 10.43 40405 20100616 JNS 10.34 10.42 10.19 10.3 34636 20100617 JNS 10.31 10.39 10.08 10.2 26475 20100618 JNS 10.21 10.3 10.17 10.22 18769 20100621 JNS 10.38 10.46 10.11 10.15 18436 20100622 JNS 10.21 10.3 9.99 10.03 29151 20100623 JNS 10 10.1 9.77 9.87 25919 20100624 JNS 9.81 9.84 9.42 9.48 32325 20100625 JNS 9.62 9.8 9.44 9.72 52328 20100628 JNS 9.72 9.91 9.62 9.73 20703 20100629 JNS 9.32 9.57 8.92 9 55669 20100630 JNS 9.04 9.25 8.84 8.88 41806 20100701 JNS 9.08 9.2 8.63 9 49174 20100702 JNS 9.07 9.18 8.76 8.87 34495 20100706 JNS 9.08 9.35 8.73 8.81 34455 20100707 JNS 8.83 9.54 8.82 9.49 48113 20100708 JNS 9.615 9.78 9.52 9.76 33039 20100709 JNS 10.13 10.15 9.86 10.09 31576 20100712 JNS 10.04 10.05 9.83 9.87 29948 20100713 JNS 10.01 10.28 10 10.24 50987 20100714 JNS 10.12 10.22 9.87 9.96 36132 20100715 JNS 10.03 10.05 9.72 9.96 46441 20100716 JNS 9.79 9.84 9.39 9.45 47192 20100719 JNS 9.46 9.54 9.23 9.46 31766 20100720 JNS 9.23 9.59 9.18 9.57 35214 20100721 JNS 9.75 9.78 9.45 9.47 40028 20100722 JNS 9.99 11.04 9.75 10.59 141643 20100723 JNS 10.61 10.7508 10.39 10.71 62987 20100726 JNS 10.74 11.01 10.6 10.9 40445 20100727 JNS 10.94 11.08 10.66 10.7 35694 20100728 JNS 10.62 10.79 10.5 10.58 25690 20100729 JNS 10.68 10.95 10.38 10.55 36579 20100730 JNS 10.38 10.65 10.35 - ---- - -FII 22.81 23.04 22.4 22.4 17874 20100525 FII 21.91 22.55 21.8 22.51 20575 20100526 FII 22.68 22.83 22.27 22.38 16335 20100527 FII 22.72 22.77 22.27 22.73 19763 20100528 FII 22.61 22.69 22.1 22.21 15112 20100601 FII 21.99 22.18 21.6 21.6 11698 20100602 FII 21.74 21.76 21.38 21.58 30593 20100603 FII 21.7 22.29 21.57 22.26 22183 20100604 FII 21.7 22.2826 21.7 21.8 23094 20100607 FII 21.99 21.99 21.17 21.17 17787 20100608 FII 21.15 21.29 20.86 21.26 14701 20100609 FII 21.41 21.41 20.82 20.9 21190 20100610 FII 21.18 21.81 21.06 21.81 16537 20100611 FII 21.66 22.3003 21.55 22.25 16034 20100614 FII 22.68 22.95 22.23 22.26 25142 20100615 FII 22.36 22.75 22.22 22.72 17777 20100616 FII 22.7 22.78 22.47 22.69 9105 20100617 FII 22.64 22.72 22.19 22.45 8317 20100618 FII 22.44 22.52 22.06 22.15 19236 20100621 FII 22.36 22.39 21.93 22.01 14594 20100622 FII 22.01 22.13 21.68 21.69 11654 20100623 FII 21.75 21.96 21.66 21.8 10700 20100624 FII 21.68 21.68 21.08 21.13 8821 20100625 FII 21.21 21.44 21.06 21.32 15394 20100628 FII 21.39 21.87 21.32 21.61 12457 20100629 FII 21.39 21.49 20.82 21.05 20192 20100630 FII 20.96 21.16 20.67 20.71 15193 20100701 FII 20.67 20.93 20.28 20.59 12676 20100702 FII 20.83 20.83 20.34 20.49 5784 20100706 FII 20.65 20.88 20.26 20.39 8066 20100707 FII 20.45 21.07 20.45 21.04 10087 20100708 FII 21.25 21.37 20.89 21.1 12988 20100709 FII 21.18 21.33 21.07 21.24 12800 20100712 FII 21.17 21.28 21.01 21.12 8105 20100713 FII 21.28 21.42 21.12 21.23 21004 20100714 FII 21.24 21.41 21.08 21.38 18182 20100715 FII 21.34 21.38 20.79 21.04 14446 20100716 FII 20.88 21.32 20.76 20.84 20999 20100719 FII 20.93 21.08 20.74 20.96 9614 20100720 FII 20.65 21.35 20.62 21.33 8605 20100721 FII 21.55 21.86 21.36 21.38 20446 20100722 FII 21.54 22.15 21.54 22.05 20595 20100723 FII 21.93 21.93 20.67 20.98 25876 20100726 FII 21.03 21.1 20.71 21.1 13590 20100727 FII 21.27 21.4 21.11 21.29 10620 20100728 FII 21.22 21.46 21.12 21.13 7657 20100729 FII 21.23 21.61 21.23 21.53 15506 20100730 FII 21.29 21.59 21.09 21.22 14680 20100802 FII 21.5 21.68 21.2 21.67 31351 20100803 FII 21.67 21.7 21.23 21.24 19218 20100804 FII 21.13 21.55 20.98 21.53 17016 20100805 FII 21.37 21.85 21.36 21.73 16172 20100806 FII 21.49 21.59 21.04 21.35 10262 20100809 FII 21.38 21.725 21.35 21.6 11308 20100810 FII 21.38 21.63 21.3 21.45 8552 20100811 FII 21.06 21.07 20.67 20.75 10544 20100812 FII 20.51 20.82 20.43 20.61 9405 20100813 FII 20.56 20.61 20.38 20.43 5783 20100816 FII 20.33 20.53 20.15 20.17 14647 20100817 FII 20.37 20.82 20.37 20.74 10599 20100819 FII 20.63 20.7 20.2 20.27 6051 20100820 FII 20.13 20.5 20.04 20.49 9936 20090821 FIS 24.67 24.87 24.42 24.85 28481 20090824 FIS 24.94 25.17 24.85 25.01 25462 20090825 FIS 25.08 25.32 24.9 24.98 24190 20090826 FIS 24.96 25.09 24.88 25.06 22744 20090827 FIS 25 25.05 24.4675 24.83 21690 20090828 FIS 25.05 25.05 24.63 24.72 13820 20090831 FIS 24.52 24.75 24.36 24.56 13747 20090901 FIS 24.42 24.835 24.04 24.06 16003 20090902 FIS 23.97 24.1 23.82 23.92 17480 20090903 FIS 23.98 24.35 23.62 24.33 63393 20090904 FIS 24.2 24.4 23.77 24.18 40126 20090909 FIS 24 24.52 23.94 24.48 24391 20090910 FIS 24.48 24.55 24.28 24.35 26143 20090911 FIS 24.34 25.01 24.28 24.82 34233 20090914 FIS 24.71 24.97 24.47 24.85 20690 20090915 FIS 24.89 24.92 24.64 24.84 18093 20090916 FIS 24.83 25.12 24.67 25.12 17019 20090917 FIS 25.07 25.23 24.99 25.05 16106 20090918 FIS 25.12 25.22 24.73 24.93 20846 20090921 FIS 24.82 25.05 24.59 24.93 18805 20090922 FIS 24.97 24.99 24.68 24.73 15484 20090923 FIS 24.71 25.37 24.63 25.16 48178 20090924 FIS 25.23 25.31 24.99 25.3 24016 20090925 FIS 25.3 26 25.22 25.4 46317 20090928 FIS 25.5 25.89 25.44 25.7 19558 20090929 FIS 25.64 25.725 25.36 25.4 23362 20090930 FIS 25.17 25.56 24.935 25.51 36077 20091001 FIS 25.4 25.66 24.85 24.85 291030 20091002 FIS 24.55 24.74 23.96 23.99 57072 20091005 FIS 24.07 24.37 23.89 23.91 55853 20091006 FIS 24.01 24.49 23.93 24.28 45289 20091007 FIS 24.23 24.48 23.93 24.13 37881 20091008 FIS - ---- - -20100726 JNS 10.74 11.01 10.6 10.9 40445 20100727 JNS 10.94 11.08 10.66 10.7 35694 20100728 JNS 10.62 10.79 10.5 10.58 25690 20100729 JNS 10.68 10.95 10.38 10.55 36579 20100730 JNS 10.38 10.65 10.35 10.48 27027 20100802 JNS 10.66 10.88 10.49 10.88 35182 20100803 JNS 10.82 10.92 10.6675 10.69 18053 20100804 JNS 10.76 10.93 10.625 10.91 19306 20100805 JNS 10.76 10.92 10.68 10.91 15024 20100806 JNS 10.75 10.87 10.51 10.7 27226 20100809 JNS 10.8 10.91 10.67 10.79 24824 20100810 JNS 10.64 10.7 10.28 10.35 32777 20100811 JNS 10.13 10.16 9.88 9.88 38485 20100812 JNS 9.74 9.83 9.64 9.7 25766 20100813 JNS 9.63 9.8 9.6 9.75 23862 20100816 JNS 9.7 9.84 9.53 9.78 21572 20100817 JNS 9.91 10.23 9.85 10.06 17651 20100819 JNS 10.1 10.17 9.9 9.97 58803 20100820 JNS 9.97 10.06 9.83 10 30464 20090821 JPM 42.86 43.81 42.53 43.66 428635 20090824 JPM 43.86 44.24 42.95 43.01 403851 20090825 JPM 43.39 44.14 43.3 43.58 348356 20090826 JPM 43.39 43.78 42.92 43.3 319083 20090827 JPM 43.05 43.63 42.54 43.45 289756 20090828 JPM 43.81 43.86 42.51 42.92 272691 20090831 JPM 42.44 43.6 42.06 43.46 322510 20090901 JPM 43.08 43.82 41.56 41.67 514753 20090902 JPM 41.51 42.11 40.75 40.86 358984 20090903 JPM 41.23 42.25 41.11 42.11 350278 20090904 JPM 42.33 42.49 41.79 42.34 218801 20090909 JPM 42.6 43.07 42.39 42.86 290392 20090910 JPM 42.73 43.15 42.2 43.02 251165 20090911 JPM 43.13 43.39 42.48 42.5 272963 20090914 JPM 42.08 43.85 42.01 43.75 289502 20090915 JPM 43.61 44.195 42.55 43.19 499888 20090916 JPM 43.35 44.68 43.21 44.65 387218 20090917 JPM 44.29 45.11 44.2 44.96 357056 20090918 JPM 45.24 45.34 44.7 44.95 394985 20090921 JPM 44.54 44.8 44.22 44.55 240699 20090922 JPM 44.81 46.49 44.48 46.47 411577 20090923 JPM 46.4 46.5 44.98 45.06 344523 20090924 JPM 45.21 45.8 44.26 44.37 422313 20090925 JPM 44.15 44.28 43.34 43.65 310612 20090928 JPM 43.97 44.83 43.69 44.81 258260 20090929 JPM 44.89 45.2 44.43 44.88 239305 20090930 JPM 44.8 44.89 43.43 43.82 409039 20091001 JPM 43.4 43.56 41.36 41.37 505626 20091002 JPM 40.82 42.4 40.53 41.86 430622 20091005 JPM 42.48 43.93 42.35 43.8 343721 20091006 JPM 44.36 45 44.07 44.91 417053 20091007 JPM 44.6 45.82 44.46 45.7 361486 20091008 JPM 46.04 46.44 45.05 45.3 366276 20091009 JPM 45.46 45.94 45.08 45.85 260341 20091012 JPM 46.37 46.42 45.35 46.08 242205 20091013 JPM 45.65 46.03 44.53 45.66 457018 20091014 JPM 47.19 47.47 46.63 47.16 703686 20091015 JPM 46.36 47.32 46.36 47.16 361059 20091016 JPM 46.7 46.88 46 46.06 374589 20091019 JPM 46.42 46.43 45.45 45.98 304153 20091020 JPM 45.81 46.59 45.77 46.03 306188 20091021 JPM 46.02 46.42 44.65 44.65 329915 20091022 JPM 44.92 45.87 44.83 45.71 323987 20091023 JPM 45.7 46.195 44.96 45.23 276394 20091026 JPM 45.12 45.21 43.55 43.82 420854 20091027 JPM 43.99 44.66 43.67 43.9 380863 20091028 JPM 43.73 43.81 42.5 42.68 456794 20091105 JPM 42.6 43.93 42.4 43.87 328932 20091106 JPM 43.14 43.69 42.91 43.48 271449 20091109 JPM 43.93 44.39 43.3 44.35 388454 20091110 JPM 44.14 44.32 43.55 44.17 309801 20091111 JPM 44.34 44.99 43.78 44.32 326748 20091112 JPM 44.08 44.65 43 43.3 343833 20091113 JPM 43.16 43.29 42.36 42.9 366556 20091116 JPM 43.25 43.6089 42.76 43.04 435356 20091117 JPM 42.92 43.19 42.54 43.16 258596 20091118 JPM 43.14 43.5 42.94 43.38 204242 20091119 JPM 43.1 43.18 42.26 42.55 268839 20091120 JPM 42.47 42.74 42.15 42.46 253324 20091123 JPM 42.95 43.64 42.7 43.28 298106 20091124 JPM 43.26 43.28 42.24 42.48 318817 20091125 JPM 42.67 42.67 41.94 42.16 261311 20091127 JPM 40.98 41.9 40.75 41.33 262300 20091130 JPM 41.55 42.65 41.49 42.49 382405 20091201 JPM 42.61 42.71 41.62 42.22 392201 20091202 JPM 42.15 42.15 41.47 41.93 325196 20091203 JPM 42.3 43.09 41.31 41.4 533143 20091204 JPM 42.25 42.51 41.22 41.74 614902 20091207 JPM 41.63 41.96 41.06 41.25 329495 20091208 JPM 41.01 41.4 40.625 41.21 418788 20091209 JPM 41.25 41.51 40.6 41.19 424997 20091210 JPM 41.36 41.56 40.6575 41.27 363829 20091211 JPM 40.99 41.25 40.75 40.96 466160 20091214 JPM 41.01 41.93 40.7 41.77 353407 - ---- - -SE 19.36 19.85 19.15 19.85 35495 20100603 SE 19.81 20.16 19.74 20.11 43587 20100604 SE 19.81 19.94 19.27 19.43 44531 20100607 SE 19.51 19.69 19.23 19.23 42711 20100608 SE 19.31 19.79 19.09 19.75 42038 20100609 SE 19.93 20.24 19.63 19.74 36866 20100610 SE 20.1 20.57 20.1 20.55 43411 20100611 SE 20.39 20.63 20.2 20.62 25114 20100614 SE 20.92 21.09 20.59 20.68 35903 20100615 SE 20.9 21.38 20.89 21.38 29638 20100616 SE 21.23 21.45 21.14 21.32 24749 20100617 SE 21.9 21.9 21.2 21.49 27252 20100618 SE 21.53 21.77 21.38 21.69 42768 20100621 SE 21.96 22.12 21.48 21.6 30212 20100622 SE 21.72 21.75 21.11 21.23 36935 20100623 SE 21.18 21.24 20.765 21.02 35207 20100624 SE 20.79 21.11 20.66 20.76 29002 20100625 SE 20.79 21.04 20.62 20.91 45066 20100628 SE 20.9 20.94 20.64 20.83 35523 20100629 SE 20.57 20.68 20.12 20.25 48700 20100630 SE 20.25 20.51 20 20.07 34515 20100701 SE 20.1 20.3 19.67 20.24 59282 20100702 SE 20.27 20.59 20.12 20.18 30495 20100706 SE 20.48 20.6 20.11 20.35 70033 20100707 SE 20.35 20.92 20.35 20.92 42086 20100708 SE 21.1 21.31 20.94 21.23 22899 20100709 SE 21.27 21.36 21.11 21.32 17312 20100712 SE 21.24 21.76 21.19 21.46 29405 20100713 SE 21.66 21.76 21.43 21.47 31924 20100714 SE 21.35 21.44 21.1 21.22 42642 20100715 SE 21.24 21.3 20.95 21.21 37858 20100716 SE 21.15 21.15 20.73 20.83 34138 20100719 SE 20.91 21.09 20.73 20.91 23898 20100720 SE 20.62 21.25 20.56 21.22 44016 20100721 SE 21.28 21.34 20.65 20.83 42265 20100722 SE 21.07 21.36 21.06 21.22 31387 20100723 SE 21.24 21.3 21.03 21.23 35502 20100726 SE 21.16 21.53 21.16 21.49 26866 20100727 SE 21.59 21.65 21.35 21.45 29764 20100728 SE 21.55 21.59 21.09 21.12 49341 20100729 SE 21.28 21.36 20.56 20.69 69609 20100730 SE 20.44 20.84 20.4 20.79 61928 20100802 SE 21.18 21.31 21.04 21.29 36527 20100803 SE 21.22 21.4 21.052 21.24 28767 20100804 SE 21.35 21.58 21.2 21.52 41766 20100805 SE 21.42 21.83 21.2 21.79 37688 20100806 SE 21.64 22 21.59 21.93 44577 20100809 SE 22.07 22.11 21.93 21.96 23707 20100810 SE 21.77 21.89 21.47 21.81 45474 20100811 SE 21.34 21.34 20.92 20.95 31296 20100812 SE 20.71 21.0391 20.65 20.92 27843 20100813 SE 20.9 21.34 20.78 21.27 37654 20100816 SE 21.22 21.22 20.91 21.06 29018 20100817 SE 21.25 21.68 21.16 21.62 33565 20100819 SE 21.36 21.37 20.9 21.04 29220 20100820 SE 20.86 21.05 20.77 20.98 28612 20090821 SEE 18.28 18.85 18.26 18.78 11609 20090824 SEE 18.89 18.97 18.55 18.61 7169 20090825 SEE 18.76 19.44 18.72 19.22 16527 20090826 SEE 19.14 19.43 18.94 19.15 10630 20090827 SEE 19.31 19.31 18.831 19.21 5502 20090828 SEE 19.39 19.42 19.06 19.24 6756 20090831 SEE 19.04 19.08 18.71 18.91 6295 20090901 SEE 18.81 18.91 18.19 18.22 21821 20090902 SEE 18.13 18.27 17.88 18.11 7681 20090903 SEE 18.14 18.44 17.91 18.43 7143 20090904 SEE 18.41 18.67 18.27 18.58 7190 20090909 SEE 18.71 19.31 18.57 19.05 11468 20090910 SEE 18.97 19.16 18.67 19.15 7279 20090911 SEE 19.13 19.19 18.75 19.05 7919 20090914 SEE 19.51 20.23 19.38 20.16 17063 20090915 SEE 20.35 20.63 20.2 20.52 10954 20090916 SEE 20.58 20.84 20.25 20.75 7728 20090917 SEE 20.64 20.92 20.3 20.43 11631 20090918 SEE 20.78 20.78 20.36 20.58 9983 20090921 SEE 20.36 20.46 20.15 20.36 6754 20090922 SEE 20.48 20.5 20.27 20.36 4014 20090923 SEE 20.46 20.46 19.93 19.96 5687 20090924 SEE 20.01 20.1 19.53 19.58 7198 20090925 SEE 19.54 19.7 19.23 19.41 6145 20090928 SEE 19.54 19.92 19.4 19.81 5098 20090929 SEE 19.62 20.07 19.62 19.89 7243 20090930 SEE 19.95 20 19.36 19.63 8562 20091001 SEE 19.62 19.62 18.89 18.95 11841 20091002 SEE 18.91 19.01 18.63 18.78 10269 20091005 SEE 18.84 19.23 18.73 19.2 9575 20091006 SEE 19.42 19.53 18.91 19.18 10580 20091007 SEE 19.08 19.38 18.99 19.38 7803 20091008 SEE 19.56 19.83 19.43 19.68 8867 20091009 SEE 19.72 19.8 19.48 19.8 4324 20091012 SEE 19.81 20.05 19.76 19.82 3569 20091013 SEE 19.8 20.1 19.75 20.04 7041 20091014 SEE 20.27 20.54 20.14 20.4 7739 20091015 SEE 20.24 20.5 20.15 20.48 7890 20091016 SEE 20.4 20.45 19.98 20.22 6534 20091019 SEE 20.21 20.59 20.14 20.55 6137 - ---- - -STI 23.79 23.86 23.3 23.64 43873 20100302 STI 23.67 24.72 23.67 24.43 76578 20100303 STI 24.51 24.64 24.08 24.16 39229 20100304 STI 24.17 24.44 24 24.38 42616 20100305 STI 24.45 25.09 24.35 25.06 49582 20100308 STI 25.02 25.9 24.96 25.64 72613 20100309 STI 25.35 26.45 25.07 25.83 105301 20100310 STI 26.02 27.25 25.92 26.49 126045 20100311 STI 26.69 27.13 26.28 27.08 66549 20100312 STI 27.55 28 26.76 26.86 89868 20100315 STI 26.72 27.39 26.72 26.99 72418 20100316 STI 27.15 27.45 26.81 27.38 68034 20100317 STI 27.3 28.39 27.27 28.09 75447 20100318 STI 28 28.13 27.12 27.38 63822 20100319 STI 27.61 27.8 26.89 27.18 69210 20100322 STI 26.39 27.15 26.39 27.09 71365 20100323 STI 26.93 27.09 26.16 26.87 78178 20100324 STI 26.67 27.3 26.67 27.26 60199 20100325 STI 27.54 27.65 26.54 26.57 84336 20100326 STI 26.71 27.07 26.25 26.5 83557 20100329 STI 26.7 26.76 26.18 26.34 32070 20100330 STI 26.35 26.75 26.15 26.34 34052 20100331 STI 26.21 26.9 26.15 26.79 56231 20100401 STI 26.97 27.23 26.84 27.16 49725 20100405 STI 27.3 27.789 27.05 27.74 63262 20100406 STI 27.59 28.97 27.43 28.71 81300 20100407 STI 29 29.41 28.34 28.53 79169 20100408 STI 28.18 28.6 27.72 28.56 67171 20100409 STI 28.7 28.82 28.24 28.65 40028 20100412 STI 28.91 29.64 28.79 29.44 69261 20100413 STI 29.28 29.28 28.71 29.02 54424 20100414 STI 29.31 30.29 29.17 30.28 81119 20100415 STI 30.26 30.42 29.59 29.77 68068 20100416 STI 29.64 29.64 27.64 28.48 148521 20100419 STI 28.12 29.05 27.98 28.97 88457 20100420 STI 29.01 30.29 28.76 30.19 81396 20100421 STI 29.67 31.42 29.29 29.72 134911 20100422 STI 29.24 29.46 28.4 29.32 97762 20100423 STI 29.4 29.78 29.07 29.44 64657 20100426 STI 29.43 29.61 28.24 28.37 50900 20100427 STI 28.07 29.3 27.68 27.79 113775 20100428 STI 28.4 29.45 28.37 29.12 103294 20100429 STI 29.51 29.89 28.93 29.7 59490 20100430 STI 29.49 29.97 29.41 29.6 62068 20100503 STI 29.87 30.49 29.49 30.44 54371 20100504 STI 30.04 30.19 28.96 29.15 54841 20100505 STI 28.79 30.1 28.31 29.4 51980 20100506 STI 29.26 29.81 26.29 28.04 107360 20100507 STI 28.1 28.65 26.95 27.46 99463 20100510 STI 28.97 29.65 28.32 29.1 70341 20100511 STI 28.52 30.67 28.52 30.45 98474 20100512 STI 30.58 31.92 30.43 31.85 95867 20100513 STI 31.67 32.02 31.22 31.27 59491 20100514 STI 30.78 30.97 29.29 29.82 84969 20100517 STI 29.8 30.25 28.88 29.88 70270 20100518 STI 30.19 30.22 27.47 28.03 150965 20100519 STI 27.67 28.65 27 27.54 105986 20100520 STI 26.82 27.22 26.15 26.21 116830 20100521 STI 25.55 27.27 25.38 26.99 117513 20100524 STI 26.21 26.88 25.34 25.4 89431 20100525 STI 24.58 26.32 24.39 26.31 91033 20100526 STI 26.84 27.06 26.1 26.56 91803 20100527 STI 27.12 27.69 26.44 27.61 76656 20100528 STI 27.58 27.73 26.67 26.95 53483 20100601 STI 26.58 27.19 26.1 26.17 64789 20100602 STI 26.32 27.26 26.07 27.26 73428 20100603 STI 27.52 27.59 26.68 26.9 50141 20100604 STI 26.23 26.38 24.92 25.03 106240 20100607 STI 25.16 25.52 24.41 24.43 71121 20100608 STI 24.61 25.26 24.3 25.11 97667 20100609 STI 25.4 25.53 24.64 24.73 69384 20100610 STI 25.1 25.92 24.94 25.83 63728 20100611 STI 25.39 25.92 25.16 25.89 50285 20100614 STI 25.98 26.32 25.51 25.69 48241 20100615 STI 26.13 26.44 25.81 26.37 62610 20100616 STI 26.23 26.5 26 26.36 58339 20100617 STI 26.28 26.57 25.97 26.24 45282 20100618 STI 26.32 26.54 26.09 26.2 53170 20100621 STI 26.62 26.63 25.71 25.85 57877 20100622 STI 25.9 25.93 25.19 25.24 64681 20100623 STI 25.3 25.71 24.66 25.27 57314 20100624 STI 25.08 25.14 24.28 24.37 74816 20100625 STI 24.74 25.97 24.51 25.51 102149 20100628 STI 25.67 25.7 24.92 25.16 55209 20100629 STI 24.68 24.81 23.28 23.44 102824 20100630 STI 23.5 24.04 23.12 23.3 77041 20100701 STI 23.26 23.5 21.79 22.8 138683 20100702 STI 23.03 23.03 22.11 22.44 65961 20100706 STI 22.97 23 22.37 22.62 93525 20100707 STI 22.84 24.56 22.71 24.48 141792 20100708 STI 24.96 24.96 24.05 24.67 82240 20100709 STI 24.55 25.54 24.46 25.46 54188 20100712 STI 25.24 25.48 24.8 25.18 33142 20100713 STI 25.54 26.365 25.5 26.18 63045 20100714 - ---- - -4.66 71357 20090901 THC 4.65 4.7 4.37 4.39 85639 20090902 THC 4.36 4.45 4.29 4.41 61550 20090903 THC 4.46 4.5 4.38 4.49 38656 20090904 THC 4.51 4.89 4.49 4.81 93642 20090909 THC 4.75 5.13 4.74 5.09 81474 20090910 THC 5.1 5.46 5 5.41 93595 20090911 THC 5.45 5.51 5.28 5.45 69269 20090914 THC 5.83 6.07 5.71 5.75 390102 20090915 THC 5.8 5.85 5.6 5.74 154724 20090916 THC 5.8 5.95 5.62 5.95 126437 20090917 THC 5.94 6.02 5.73 5.76 97862 20090918 THC 5.75 5.85 5.61 5.61 87967 20090921 THC 5.6 5.93 5.6 5.85 102194 20090922 THC 5.81 5.98 5.77 5.9 68500 20090923 THC 5.92 5.97 5.77 5.85 60627 20090924 THC 5.87 5.87 5.48 5.53 79313 20090925 THC 5.43 5.57 5.35 5.44 49561 20090928 THC 5.45 5.89 5.44 5.83 93893 20090929 THC 5.85 5.96 5.76 5.79 53806 20090930 THC 5.79 5.89 5.46 5.88 113832 20091001 THC 5.85 5.87 5.45 5.47 83402 20091002 THC 5.27 5.45 5.21 5.36 74425 20091005 THC 5.47 5.7 5.33 5.61 78056 20091006 THC 5.68 5.78 5.53 5.65 71170 20091007 THC 5.65 5.77 5.64 5.67 38568 20091008 THC 5.79 6.02 5.74 5.95 124838 20091009 THC 5.96 6.1 5.832 5.98 77189 20091012 THC 6.01 6.01 5.91 5.99 73281 20091013 THC 6.05 6.05 5.83 5.92 55792 20091014 THC 5.95 6 5.86 6 48291 20091015 THC 6 6.03 5.92 6 84811 20091016 THC 5.96 6.03 5.8 5.94 87231 20091019 THC 5.93 6.23 5.93 6.16 132850 20091020 THC 6.2 6.36 6.09 6.24 94913 20091021 THC 6.24 6.39 6.1 6.13 85477 20091022 THC 6.2 6.26 6.03 6.08 90436 20091023 THC 6.13 6.19 5.75 5.79 99769 20091026 THC 5.81 5.92 5.38 5.56 111755 20091027 THC 5.5 5.59 5.21 5.46 124860 20091028 THC 5.4 5.46 5.07 5.11 107471 20091105 THC 5.19 5.35 5.15 5.23 70811 20091106 THC 5.18 5.28 5.04 5.11 62519 20091109 THC 5.25 5.3 5.15 5.3 55132 20091110 THC 5.33 5.54 5.31 5.44 83917 20091111 THC 5.48 5.7 5.48 5.58 58772 20091112 THC 5.53 5.71 5.48 5.5 50286 20091113 THC 5.52 5.63 5.47 5.56 40889 20091116 THC 5.59 5.69 5.57 5.6 37777 20091117 THC 5.55 5.585 5.44 5.47 55453 20091118 THC 5.46 5.49 5.25 5.29 61717 20091119 THC 5.23 5.35 5.13 5.26 60500 20091120 THC 5.17 5.3 5.16 5.27 35835 20091123 THC 5.36 5.41 5.15 5.19 47571 20091124 THC 5.16 5.19 4.91 5.1 84287 20091125 THC 5.1 5.1 5.02 5.09 37874 20091127 THC 4.97 5.02 4.84 4.95 35892 20091130 THC 4.99 5.01 4.52 4.55 138362 20091201 THC 4.65 4.87 4.59 4.77 162599 20091202 THC 4.65 4.75 4.55 4.73 111415 20091203 THC 4.93 5.1 4.83 4.87 130171 20091204 THC 4.98 5.05 4.7 4.75 93756 20091207 THC 4.78 4.95 4.7 4.9 78440 20091208 THC 4.86 4.9 4.75 4.79 52078 20091209 THC 4.83 4.855 4.65 4.76 57006 20091210 THC 4.78 4.86 4.75 4.86 42917 20091211 THC 4.9 4.91 4.76 4.81 44567 20091214 THC 4.83 4.95 4.8 4.92 42372 20091215 THC 4.9 5.26 4.89 5.12 87824 20091216 THC 5.19 5.35 5.16 5.26 64230 20091217 THC 5.15 5.28 5.01 5.1 92451 20091218 THC 5.11 5.19 4.91 4.91 113831 20091221 THC 4.95 5.16 4.91 5.07 106673 20091222 THC 5.13 5.35 5.11 5.32 94778 20091223 THC 5.5 5.8 5.45 5.52 146551 20091224 THC 5.78 5.8 5.46 5.62 58255 20091228 THC 5.72 5.74 5.47 5.5 55243 20091229 THC 5.44 5.48 5.21 5.33 85768 20091230 THC 5.26 5.28 5.14 5.2 57086 20091231 THC 5.21 5.52 5.21 5.39 91387 20100104 THC 5.44 5.56 5.39 5.45 53531 20100105 THC 5.92 6.16 5.91 6 268586 20100106 THC 6.03 6.05 5.84 5.9 79010 20100107 THC 6.07 6.15 5.98 6.01 94128 20100108 THC 6.01 6.28 6.01 6.25 103279 20100111 THC 6.36 6.38 6.11 6.14 52282 20100112 THC 6.03 6.08 5.86 5.91 71552 20100113 THC 5.99 6.28 5.96 6.25 97055 20100114 THC 6.29 6.44 6.15 6.29 99685 20100115 THC 6.26 6.34 6.06 6.07 81164 20100119 THC 6.1 6.18 5.69 5.86 160252 20100120 THC 5.74 5.8 5.6 5.65 105644 20100121 THC 5.68 5.73 5.44 5.45 90310 20100122 THC 5.43 5.53 5.17 5.19 155699 20100125 THC 5.26 5.35 5.17 5.29 82943 20100126 THC 5.2 5.65 5.2 5.53 128071 20100127 THC 5.52 5.56 5.31 5.39 67428 20100128 THC 5.48 5.5 5.13 5.16 93648 20100129 THC 5.24 5.59 5.17 5.54 240520 20100201 THC 5.51 5.58 5.3 5.49 123133 20100202 THC 5.53 5.62 5.42 5.59 75041 20100203 THC 5.58 5.69 5.47 5.52 51625 20100204 THC 5.43 5.46 5.18 5.2 107954 20100205 THC 5.19 5.2 4.95 5.1 101381 20100208 - ---- - -77.69 21095 20090826 BCR 77.44 78.55 77.19 78.24 12723 20090827 BCR 78.21 79.19 77.83 78.99 10243 20090828 BCR 80.26 80.76 78.99 80.31 14241 20090831 BCR 80.07 80.78 79.55 80.58 17274 20090901 BCR 80.4 81.21 79.04 80.49 16996 20090902 BCR 80 81.16 80 80.63 15551 20090903 BCR 80.4 80.99 79.7 80.53 10418 20090904 BCR 80.68 80.68 79.65 80.45 9047 20090909 BCR 79.12 81.26 79.12 80.81 7811 20090910 BCR 81.12 81.16 80.19 80.75 10287 20090911 BCR 80.8 81.33 80.4 80.51 8658 20090914 BCR 80.5 81.52 80.27 81.33 6909 20090915 BCR 81.06 82.98 80.9 82.56 12022 20090916 BCR 82.43 82.83 81.18 81.29 9082 20090917 BCR 81.02 81.27 80.45 80.45 7147 20090918 BCR 80.64 80.74 80.015 80.15 10987 20090921 BCR 80 81.13 79.92 80.09 6318 20090922 BCR 80.12 80.12 79.17 79.44 6232 20090923 BCR 79.71 79.71 78.56 78.56 7574 20090924 BCR 78.45 79.04 77.91 78.1 8744 20090925 BCR 77.94 78.66 77.8 78.06 5999 20090928 BCR 78.22 79.22 78.1 78.75 4991 20090929 BCR 78.75 78.96 78 78.41 6177 20090930 BCR 78.39 78.94 77.72 78.61 8141 20091001 BCR 78.48 78.57 77.53 77.53 8495 20091002 BCR 77.35 77.66 76.75 77.39 6563 20091005 BCR 77.31 77.31 76.45 77.06 8768 20091006 BCR 77.2 77.83 76.29 77.27 6275 20091007 BCR 76.98 77.435 76.56 77.18 6491 20091008 BCR 77.17 78.47 77.17 78.08 6465 20091009 BCR 77.93 78.39 77.772 77.94 5321 20091012 BCR 77.96 78.01 77.44 77.48 5918 20091013 BCR 77.2 77.75 76.86 77.64 6688 20091014 BCR 77.4 77.97 77.24 77.59 10474 20091015 BCR 77.48 77.67 76.88 77.46 10559 20091016 BCR 77.01 77.05 76.14 76.19 12299 20091019 BCR 76.775 77.06 76.19 76.95 8291 20091020 BCR 77 77.03 75.57 75.74 9598 20091021 BCR 76.2 76.56 75.24 75.26 16804 20091022 BCR 74.8 77.37 73.99 76.88 31428 20091023 BCR 76.56 77.1 76.275 76.74 11142 20091026 BCR 76.52 77.03 75.4 75.78 11142 20091027 BCR 76.2 76.25 75.41 75.93 10544 20091028 BCR 76.12 77.16 75.52 75.56 9644 20091105 BCR 77.54 78.125 77.41 77.98 8162 20091106 BCR 77.74 78.95 77.4 78.39 8279 20091109 BCR 78.69 79.86 78.41 79.84 6186 20091110 BCR 79.57 80.73 79.57 80.66 7606 20091111 BCR 80.71 81.07 80.47 80.9 6023 20091112 BCR 80.99 80.99 79.65 80.16 4718 20091113 BCR 80.21 81.11 80.17 80.76 7143 20091116 BCR 80.805 81.86 80.74 81.65 5404 20091117 BCR 81.81 81.91 81.45 81.84 6159 20091118 BCR 81.63 82.39 81.4 81.95 5039 20091119 BCR 81.81 82.22 80.9 81.89 7751 20091120 BCR 81.88 81.88 80.45 80.72 9399 20091123 BCR 80.91 81.55 80.75 81 7686 20091124 BCR 80.9 82.02 80.75 82.01 13398 20091125 BCR 81.87 82.29 81.45 82 5635 20091127 BCR 80.69 82.39 80.35 81.86 3830 20091130 BCR 82.14 82.43 81.43 82.21 11490 20091201 BCR 82.86 83.2 82.48 83.05 8943 20091202 BCR 83.09 84.01 82.97 83.52 6816 20091203 BCR 83.18 83.74 82.75 82.87 6964 20091204 BCR 83.63 84.07 82.41 83.04 7177 20091207 BCR 83.16 83.59 82.69 82.82 6870 20091208 BCR 82.42 82.54 81.73 81.8 10052 20091209 BCR 81.66 82.12 81.27 81.8 9702 20091210 BCR 82.24 83.46 82.12 83.12 9578 20091211 BCR 83.46 83.86 82.87 83.05 7115 20091214 BCR 83.7 84.23 83.35 83.62 7880 20091215 BCR 85.21 85.21 84.18 85.02 18761 20091216 BCR 85.43 85.49 84.88 85.05 11672 20091217 BCR 84.49 84.953 84.15 84.16 7532 20091218 BCR 76.65 79.8 76.37 78.49 64485 20091221 BCR 78.79 79.77 78.25 78.64 20423 20091222 BCR 78.95 79.49 78.51 79.27 8695 20091223 BCR 78.99 79.25 78.59 78.8 6554 20091224 BCR 79.11 79.11 78.8 79.08 1925 20091228 BCR 79 79.11 78.67 78.97 5081 20091229 BCR 79.14 79.22 78.77 79 5138 20091230 BCR 78.71 79.35 78.69 79.26 4997 20091231 BCR 79.15 79.16 77.75 77.9 11547 20100104 BCR 78.59 78.94 77.85 78.68 13717 20100105 BCR 78.5 79.42 78.46 79.35 10935 20100106 BCR 79.37 79.37 78.68 79.01 7917 20100107 BCR 78.87 80.28 78.69 80.13 12870 20100108 BCR 79.89 80.54 79.08 80.51 8893 20100111 BCR 80.66 81.97 80.63 81.26 10574 20100112 BCR 81.12 81.18 79.82 80.46 7574 20100113 BCR 80.96 83.02 80.67 82.63 21721 20100114 BCR 82.61 83.56 82.29 83.55 10289 20100115 BCR 83.5 83.545 81.87 82.62 10413 20100119 BCR 83.21 84 82.83 83.83 8761 20100120 BCR 83.79 83.79 81.66 82.4 9747 20100121 BCR 82.18 - ---- - -THC 5.51 5.58 5.3 5.49 123133 20100202 THC 5.53 5.62 5.42 5.59 75041 20100203 THC 5.58 5.69 5.47 5.52 51625 20100204 THC 5.43 5.46 5.18 5.2 107954 20100205 THC 5.19 5.2 4.95 5.1 101381 20100208 THC 5.07 5.15 4.93 4.96 102280 20100209 THC 5.07 5.18 5 5.15 64560 20100210 THC 5.11 5.17 5.06 5.08 43941 20100211 THC 5.07 5.27 5.04 5.24 43546 20100212 THC 5.18 5.26 5.12 5.21 67719 20100216 THC 5.31 5.32 5.17 5.32 57902 20100217 THC 5.35 5.59 5.35 5.55 75280 20100218 THC 5.52 5.75 5.51 5.64 70371 20100219 THC 5.6 5.67 5.55 5.59 91639 20100222 THC 5.64 5.67 5.52 5.58 105614 20100223 THC 5.33 5.34 4.92 5.04 295632 20100224 THC 5.06 5.17 5.02 5.07 168689 20100225 THC 5.01 5.07 4.94 5.03 94462 20100226 THC 5.03 5.3 4.97 5.27 131615 20100301 THC 5.28 5.34 5.22 5.27 77962 20100302 THC 5.27 5.38 5.15 5.38 94704 20100303 THC 5.4 5.47 5.3 5.38 82062 20100304 THC 5.38 5.47 5.32 5.45 76306 20100305 THC 5.45 5.55 5.401 5.51 52013 20100308 THC 5.55 5.59 5.46 5.5 58912 20100309 THC 5.46 5.47 5.34 5.38 98006 20100310 THC 5.33 5.41 5.18 5.37 139540 20100311 THC 5.35 5.38 5.25 5.37 63085 20100312 THC 5.37 5.44 5.3 5.39 43987 20100315 THC 5.34 5.77 5.3 5.73 144438 20100316 THC 5.72 5.78 5.61 5.72 87100 20100317 THC 5.58 5.81 5.58 5.66 101585 20100318 THC 5.65 5.89 5.61 5.66 135163 20100319 THC 5.69 5.8 5.64 5.75 106426 20100322 THC 6.09 6.38 6.01 6.27 341340 20100323 THC 6.41 6.46 6.16 6.3 193157 20100324 THC 6.26 6.26 5.92 5.97 149926 20100325 THC 6.08 6.08 5.8 5.82 158310 20100326 THC 5.91 5.96 5.75 5.81 80851 20100329 THC 5.87 5.95 5.83 5.88 70382 20100330 THC 5.93 5.95 5.71 5.73 84287 20100331 THC 5.7 5.78 5.58 5.72 64926 20100401 THC 5.8 5.96 5.8 5.96 84686 20100405 THC 5.92 6.05 5.88 5.93 97605 20100406 THC 5.84 5.94 5.8 5.83 66200 20100407 THC 5.86 5.95 5.8 5.94 92670 20100408 THC 5.87 6.02 5.82 5.95 81046 20100409 THC 5.94 6.06 5.94 5.99 77640 20100412 THC 5.98 6.14 5.98 6.06 68495 20100413 THC 6.01 6.05 5.92 6.01 69714 20100414 THC 5.99 6.04 5.945 5.96 97224 20100415 THC 5.96 6 5.85 5.9 95002 20100416 THC 5.88 5.94 5.73 5.8 126150 20100419 THC 5.78 5.94 5.75 5.89 112406 20100420 THC 5.98 6.31 5.93 6.28 175793 20100421 THC 6.29 6.38 6.16 6.21 83620 20100422 THC 6.2 6.41 6.06 6.39 104246 20100423 THC 6.41 6.43 6.31 6.34 65224 20100426 THC 6.31 6.38 6.15 6.15 70929 20100427 THC 6.13 6.37 6.1 6.12 132748 20100428 THC 6.14 6.305 6.13 6.2 83671 20100429 THC 6.21 6.42 6.19 6.38 72822 20100430 THC 6.4 6.44 6.15 6.25 105655 20100503 THC 6.23 6.36 6.2 6.34 57507 20100504 THC 6.13 6.17 5.83 5.87 135423 20100505 THC 5.82 5.9 5.66 5.73 116988 20100506 THC 5.72 5.86 5.24 5.58 167273 20100507 THC 5.55 5.62 5.2875 5.32 116544 20100510 THC 5.61 5.71 5.54 5.61 82703 20100511 THC 5.56 5.75 5.55 5.68 59653 20100512 THC 5.69 5.77 5.51 5.77 106669 20100513 THC 5.75 5.91 5.67 5.7 116107 20100514 THC 5.65 5.7 5.52 5.6 86621 20100517 THC 5.6 5.74 5.4 5.63 87592 20100518 THC 5.64 5.7 5.39 5.52 89489 20100519 THC 5.45 5.54 5.32 5.37 76546 20100520 THC 5.34 5.44 5.18 5.18 78499 20100521 THC 5.12 5.49 5.01 5.37 164178 20100524 THC 5.48 5.68 5.39 5.54 124045 20100525 THC 5.36 5.5 5.26 5.43 107079 20100526 THC 5.49 5.65 5.45 5.51 96922 20100527 THC 5.63 5.8 5.6 5.8 61255 20100528 THC 5.79 5.79 5.63 5.72 79861 20100601 THC 5.54 5.6 4.69 4.72 580202 20100602 THC 4.9 5.165 4.85 5.09 292668 20100603 THC 5.04 5.09 4.78 5.03 210342 20100604 THC 4.94 5.13 4.89 4.92 155640 20100607 THC 5 5.34 4.76 5.11 297103 20100608 THC 5.07 5.17 4.67 4.8 253261 20100609 THC 4.83 4.97 4.76 4.78 154854 20100610 THC 4.94 5.04 4.84 5.04 153010 20100611 THC 4.98 5.07 4.94 5.07 107481 20100614 THC 5.15 5.225 4.97 5.06 127975 20100615 THC 5.24 5.28 5.0275 5.2 242921 20100616 THC 5.14 5.22 5.09 5.16 68734 20100617 THC 5.13 5.18 4.93 5.02 141527 20100618 THC 5.02 5.04 4.85 4.9 162205 20100621 THC 4.97 4.99 4.71 4.74 125639 20100622 THC 4.74 4.83 4.68 4.7 85307 20100623 THC 4.71 4.84 4.6 4.77 119881 20100624 THC 4.76 4.8 4.6 4.62 122849 20100625 THC 4.64 4.72 4.58 4.71 87402 20100628 THC 4.72 4.82 4.65 - ---- - -10.6 10.66 60433 20091127 DHI 10.26 10.62 10.05 10.54 32793 20091130 DHI 10.45 10.61 10.17 10.28 76018 20091201 DHI 10.4 10.53 10.22 10.42 61511 20091202 DHI 10.33 10.51 9.78 10.04 155602 20091203 DHI 10.14 10.16 9.93 10 88916 20091204 DHI 10.16 10.36 9.89 10.1 87459 20091207 DHI 9.99 10.2 9.865 9.9 90100 20091208 DHI 9.81 10.06 9.71 9.85 62465 20091209 DHI 9.97 9.97 9.69 9.84 48746 20091210 DHI 9.93 10.07 9.84 9.89 60657 20091211 DHI 9.92 9.9785 9.71 9.86 41815 20091214 DHI 9.98 10.09 9.73 10.07 38322 20091215 DHI 10.07 10.17 9.78 9.81 50547 20091216 DHI 9.94 10.37 9.87 10.29 74415 20091217 DHI 10.17 10.34 10.08 10.25 60182 20091218 DHI 10.31 10.53 10.21 10.53 114526 20091221 DHI 10.79 10.8 10.5 10.74 63023 20091222 DHI 10.76 11.17 10.71 11.15 93599 20091223 DHI 11.28 11.33 10.99 11.12 79780 20091224 DHI 11.09 11.14 11.05 11.12 15890 20091228 DHI 11.14 11.25 10.84 10.96 53858 20091229 DHI 10.97 11.12 10.75 10.93 49061 20091230 DHI 10.79 11.1 10.76 10.99 40139 20091231 DHI 10.94 11.03 10.83 10.87 29864 20100104 DHI 10.96 11.18 10.87 11.16 57990 20100105 DHI 11.1 11.59 10.945 11.56 102544 20100106 DHI 11.45 11.76 11.39 11.66 84102 20100107 DHI 11.94 12.6333 11.92 12.27 138087 20100108 DHI 12.12 12.31 12.04 12.17 57206 20100111 DHI 12.29 12.32 12.02 12.24 37460 20100112 DHI 12.09 12.225 11.85 12.21 59820 20100113 DHI 12.24 12.57 12.04 12.42 62783 20100114 DHI 12.33 12.56 12.23 12.25 43447 20100115 DHI 12.19 12.38 11.94 12.14 46860 20100119 DHI 12.1 12.495 12.09 12.33 44561 20100120 DHI 12.16 12.32 12.08 12.13 51945 20100121 DHI 12.11 12.17 11.52 11.55 72756 20100122 DHI 11.52 11.86 11.11 11.2 117475 20100125 DHI 11.3 11.58 11.17 11.37 60310 20100126 DHI 11.25 11.59 11.2 11.29 72662 20100127 DHI 11.21 11.72 11.17 11.67 90993 20100128 DHI 11.78 12.04 11.53 11.79 94370 20100129 DHI 11.96 12.12 11.77 11.79 67884 20100201 DHI 11.83 12.04 11.63 11.91 68157 20100202 DHI 12.79 13.355 12.23 13.21 288143 20100203 DHI 13.27 13.305 12.81 13.25 117121 20100204 DHI 13.03 13.34 12.94 13.21 137177 20100205 DHI 13.08 13.14 12.16 12.67 143734 20100208 DHI 12.72 13.26 12.47 12.92 86915 20100209 DHI 13.08 13.16 12.605 12.98 84932 20100210 DHI 12.97 13.07 12.59 12.85 73130 20100211 DHI 12.85 13.22 12.695 13.12 65258 20100212 DHI 13.25 13.42 12.96 13.07 83256 20100216 DHI 13.3 13.33 13.05 13.22 45824 20100217 DHI 13.43 13.53 12.94 13.12 69247 20100218 DHI 12.98 13.03 12.69 12.78 72085 20100219 DHI 12.74 13 12.74 12.95 77251 20100222 DHI 13 13.09 12.77 12.92 62027 20100223 DHI 12.88 12.975 12.43 12.57 95564 20100224 DHI 12.63 12.65 12.04 12.34 94375 20100225 DHI 12.08 12.35 11.96 12.35 60017 20100226 DHI 12.37 12.45 12.02 12.36 52503 20100301 DHI 12.37 12.585 12.37 12.56 38737 20100302 DHI 12.66 12.72 12.4 12.47 38059 20100303 DHI 12.56 12.8 12.465 12.57 54716 20100304 DHI 12.59 12.72 12.31 12.49 44049 20100305 DHI 12.58 12.95 12.55 12.87 64969 20100308 DHI 12.87 12.99 12.79 12.96 28706 20100309 DHI 12.91 13.17 12.83 13.09 50213 20100310 DHI 13.1 13.23 12.9 13.01 50131 20100311 DHI 12.95 12.98 12.73 12.96 43454 20100312 DHI 12.99 13.01 12.78 13 45720 20100315 DHI 12.98 13.029 12.64 12.84 35303 20100316 DHI 12.8 13.15 12.6 13.03 50426 20100317 DHI 13.05 13.17 12.79 12.89 48752 20100318 DHI 12.93 12.99 12.66 12.76 29390 20100319 DHI 12.81 12.93 12.5 12.51 55931 20100322 DHI 12.4 12.79 12.37 12.75 33722 20100323 DHI 12.83 12.88 12.65 12.76 51373 20100324 DHI 12.95 13.07 12.76 12.85 52724 20100325 DHI 12.91 13.4 12.91 12.97 61700 20100326 DHI 13.03 13.38 12.97 13.13 44007 20100329 DHI 13.21 13.23 12.74 13.03 50741 20100330 DHI 12.99 13.11 12.72 12.8 40758 20100331 DHI 12.73 12.87 12.53 12.6 54078 20100401 DHI 12.72 12.81 12.4 12.51 40378 20100405 DHI 12.62 12.79 12.46 12.59 43647 20100406 DHI 12.52 12.59 12.32 12.52 55899 20100407 DHI 12.54 12.55 11.86 11.93 115183 20100408 DHI 11.9 12.03 11.75 12.01 79148 20100409 DHI 12.04 12.185 11.98 12.14 38701 20100412 DHI 12.19 12.24 11.89 12.03 67469 20100413 DHI 12.04 12.27 12.01 12.18 69399 20100414 DHI 12.25 - ---- - -25.34 99365 20091111 CHK 25.65 25.81 25.02 25.18 128210 20091112 CHK 25.17 25.69 24.6 24.71 166518 20091113 CHK 24.87 25.2 24.57 25.03 132923 20091116 CHK 25.27 25.61 24.96 25.14 154597 20091117 CHK 25.1 25.12 24.2 24.3 198765 20091118 CHK 24.6 24.67 23.8 24.08 183387 20091119 CHK 23.91 23.94 23.19 23.38 141923 20091120 CHK 23.2 23.37 22.77 23.03 130400 20091123 CHK 23.63 23.79 23.1 23.2 134124 20091124 CHK 23.19 23.69 22.775 23.65 140035 20091125 CHK 23.82 24.95 23.43 24.86 205862 20091127 CHK 23.82 24.49 23.5 24.17 106310 20091130 CHK 24 24.62 23.7 23.92 167220 20091201 CHK 24.29 24.58 24 24.1 120845 20091202 CHK 24.05 24.05 23.19 23.4 176892 20091203 CHK 23.55 23.55 22.96 23.03 134563 20091204 CHK 23.45 23.55 22.2 22.57 257800 20091207 CHK 22.75 23.37 22.65 22.8 165841 20091208 CHK 22.92 22.98 22.42 22.55 154343 20091209 CHK 22.82 22.86 22.06 22.44 137203 20091210 CHK 22.66 23.3 22.5 23.17 183380 20091211 CHK 23.28 23.46 22.9 23.03 124207 20091214 CHK 24.8 24.81 24.18 24.37 332270 20091215 CHK 24.48 24.8 24.33 24.54 159876 20091216 CHK 24.82 25.0995 24.61 24.91 139990 20091217 CHK 24.78 25.27 24.42 25 175842 20091218 CHK 25.5 26.38 25.5 26.06 256946 20091221 CHK 26.69 26.75 26.36 26.38 133205 20091222 CHK 26.7 26.93 26.41 26.81 118373 20091223 CHK 27.02 27.49 26.84 27.32 94445 20091224 CHK 27.57 28.08 27.53 27.83 90637 20091228 CHK 28.16 28.23 27.22 27.59 148475 20091229 CHK 27.56 27.9 26.71 26.73 146376 20091230 CHK 26.4 26.74 26.27 26.36 89524 20091231 CHK 26.36 26.58 25.78 25.88 97606 20100104 CHK 27.43 28.11 26.92 28.09 294671 20100105 CHK 28.28 29.12 28.2 28.97 271528 20100106 CHK 29.21 29.22 28.53 28.65 151891 20100107 CHK 28.63 28.8 28.18 28.72 131613 20100108 CHK 28.39 28.92 28.05 28.91 110302 20100111 CHK 28.98 28.98 27.73 28 142301 20100112 CHK 27.51 27.7 27.17 27.58 129900 20100113 CHK 27.42 27.94 26.92 27.82 105042 20100114 CHK 28 28.38 27.52 27.67 158822 20100115 CHK 27.52 28.09 27.25 27.91 172501 20100119 CHK 27.67 28.26 27.5 28.21 104549 20100120 CHK 27.8 27.87 27.36 27.66 100372 20100121 CHK 27.91 28.25 27.17 27.18 164934 20100122 CHK 27.05 27.68 26.48 26.62 159938 20100125 CHK 26.88 27.36 26.72 26.96 93468 20100126 CHK 26.65 27.12 26.32 26.53 100996 20100127 CHK 26.48 26.54 25.26 25.93 171954 20100128 CHK 25.63 25.86 25.03 25.51 179526 20100129 CHK 25.7 26.07 24.64 24.78 153138 20100201 CHK 25.08 25.91 25.08 25.86 106248 20100202 CHK 26.02 26.33 25.59 26.25 79747 20100203 CHK 26.16 26.44 25.68 25.83 70494 20100204 CHK 25.29 25.34 24.13 24.18 148629 20100205 CHK 24.25 24.82 23.56 24.52 168326 20100208 CHK 24.71 24.97 24.151 24.24 98693 20100209 CHK 24.68 24.87 24.02 24.51 115952 20100210 CHK 24.36 24.67 23.85 24.4 79591 20100211 CHK 24.39 25.17 24.25 25.13 95451 20100212 CHK 24.64 25.16 24.31 24.96 104322 20100216 CHK 25.56 25.99 25.4811 25.83 90933 20100217 CHK 26.2 26.44 25.68 26.36 146092 20100218 CHK 27.12 27.56 26.85 27.46 232111 20100219 CHK 27.32 27.81 27.27 27.59 133841 20100222 CHK 27.75 27.79 26.945 27.1 137803 20100223 CHK 26.91 26.91 26.26 26.3 148778 20100224 CHK 26.48 26.69 26.25 26.54 105941 20100225 CHK 26.14 26.75 25.8401 26.73 137671 20100226 CHK 26.8 26.88 26.275 26.57 97169 20100301 CHK 26.73 26.84 26.47 26.68 91030 20100302 CHK 26.91 27.17 26.68 26.74 94158 20100303 CHK 26.87 27.01 26.67 26.8 76416 20100304 CHK 26.76 26.91 26.03 26.19 109936 20100305 CHK 26.38 26.5 26.1724 26.31 86833 20100308 CHK 26.16 26.35 25.48 25.59 161893 20100309 CHK 25.45 26.24 25.32 25.7 325373 20100310 CHK 25.9 25.95 25.38 25.66 124967 20100311 CHK 25.61 25.86 25.44 25.79 93378 20100312 CHK 25.92 25.98 25.46 25.64 109519 20100315 CHK 25.39 25.53 24.93 25.42 142453 20100316 CHK 25.44 25.55 25.18 25.42 112840 20100317 CHK 25.46 25.55 24.96 25.05 162725 20100318 CHK 24.81 24.92 23.75 23.79 289281 20100319 CHK 24.07 24.43 23.4 24.21 261577 20100322 CHK 23.75 23.75 23.18 23.24 367273 20100323 CHK 23.33 23.47 22.96 23.27 335134 20100324 CHK 23.06 23.68 23 23.11 282260 20100325 CHK 23.35 23.4 22.38 22.43 283462 - ---- - -22.74 66809 20100121 SE 22.77 23.06 22.4 22.61 71435 20100122 SE 22.48 22.5 21.94 21.99 70537 20100125 SE 22.1 22.45 22.1 22.29 43780 20100126 SE 22.1 22.52 22.1 22.26 41357 20100127 SE 22.26 22.37 21.69 22.04 46384 20100128 SE 22.17 22.5 21.62 21.81 39028 20100129 SE 21.9 22.05 21.2207 21.25 52884 20100201 SE 21.39 21.73 21.35 21.73 38897 20100202 SE 21.77 22.02 21.48 21.98 43712 20100203 SE 21.96 22.05 21.64 21.7 35403 20100204 SE 21.48 21.7 20.91 20.93 48844 20100205 SE 20.97 21.15 20.37 20.99 44617 20100208 SE 21.03 21.16 20.75 20.76 35074 20100209 SE 21.14 21.41 20.98 21.02 54013 20100210 SE 20.94 20.94 20.47 20.64 44973 20100211 SE 20.56 20.76 20.44 20.72 39186 20100212 SE 20.51 20.82 20.37 20.73 43161 20100216 SE 20.94 21.38 20.94 21.3 37072 20100217 SE 21.36 21.47 21.3 21.38 27535 20100218 SE 21.35 21.5 21.16 21.49 29982 20100219 SE 21.35 21.82 21.35 21.7 30634 20100222 SE 21.76 21.82 21.585 21.6 23527 20100223 SE 21.49 21.57 21.23 21.3 24950 20100224 SE 21.31 21.75 21.19 21.72 45130 20100225 SE 21.47 21.79 21.3 21.75 26961 20100226 SE 21.81 21.9 21.62 21.8 24838 20100301 SE 21.9 22.1067 21.86 21.98 32550 20100302 SE 22.02 22.12 21.88 21.98 33003 20100303 SE 21.99 22.11 21.82 21.88 27409 20100304 SE 21.84 22 21.61 21.72 30875 20100305 SE 21.83 22.13 21.78 22.1 31470 20100308 SE 22.1 22.24 22 22.07 19768 20100309 SE 21.86 22.09 21.83 22 23714 20100310 SE 22.02 22.38 21.94 22.32 40418 20100311 SE 22.32 22.37 22.15 22.32 20805 20100312 SE 22.45 22.49 22.15 22.31 18561 20100315 SE 22.39 22.44 22.01 22.32 23823 20100316 SE 22.41 22.475 22.2561 22.44 18240 20100317 SE 22.42 22.62 22.38 22.45 22397 20100318 SE 22.49 22.55 22.25 22.5 27080 20100319 SE 22.53 22.65 22.09 22.22 44475 20100322 SE 22.02 22.32 21.97 22.26 22251 20100323 SE 22.33 22.51 22.175 22.48 26028 20100324 SE 22.39 22.47 22.18 22.29 26304 20100325 SE 22.47 22.59 22.375 22.41 39305 20100326 SE 22.39 22.75 22.39 22.57 39928 20100329 SE 22.7 22.96 22.66 22.82 43033 20100330 SE 22.87 23 22.7 22.73 28671 20100331 SE 22.71 22.71 22.43 22.53 37773 20100401 SE 22.71 22.88 22.55 22.84 20138 20100405 SE 22.9 23.29 22.86 23.24 26490 20100406 SE 23.16 23.39 23.08 23.21 26269 20100407 SE 23.2 23.28 22.99 23.06 30596 20100408 SE 23 23.19 22.8 23.14 20718 20100409 SE 23.12 23.32 22.9 23.29 20115 20100412 SE 23.2 23.38 23.17 23.33 18928 20100413 SE 23.24 23.24 22.91 23.15 18753 20100414 SE 23.11 23.35 23.06 23.35 18149 20100415 SE 23.29 23.35 23.12 23.29 22041 20100416 SE 23.21 23.21 22.7 22.88 34635 20100419 SE 22.71 23.16 22.71 23.16 21517 20100420 SE 23.29 23.43 23.27 23.31 19066 20100421 SE 23.35 23.37 23.11 23.24 21997 20100422 SE 23.04 23.17 22.9 23.14 25886 20100423 SE 23.17 23.47 22.96 23.47 29973 20100426 SE 23.47 23.53 23.34 23.38 21036 20100427 SE 23.32 23.41 22.79 22.85 30564 20100428 SE 22.99 23.24 22.86 23.15 30976 20100429 SE 23.39 23.57 23.29 23.44 29892 20100430 SE 23.44 23.67 23.31 23.34 26721 20100503 SE 23.47 23.85 23.43 23.74 36547 20100504 SE 23.48 23.5 23.05 23.24 37284 20100505 SE 23.06 23.14 22.5 22.62 36347 20100506 SE 22.51 22.81 19.45 21.59 95495 20100507 SE 21.51 21.84 20.86 21.29 87098 20100510 SE 22.16 22.55 22.09 22.52 50314 20100511 SE 22.34 22.95 22.34 22.67 38619 20100512 SE 22.38 22.73 22.24 22.67 31153 20100513 SE 22.59 22.82 22.38 22.38 29009 20100514 SE 22.31 22.4 21.75 22.01 37608 20100517 SE 22.07 22.285 21.27 21.74 37951 20100518 SE 21.96 22.1 21.44 21.53 33324 20100519 SE 21.42 21.52 20.79 21.11 36517 20100520 SE 19.8 20.02 19.1 19.37 131282 20100521 SE 18.66 19.73 18.57 19.68 63299 20100524 SE 19.62 19.69 19.34 19.34 44882 20100525 SE 18.79 19.31 18.63 19.3 58107 20100526 SE 19.46 19.8 19.41 19.47 57298 20100527 SE 19.82 20.25 19.79 20.23 35546 20100528 SE 20.23 20.32 19.88 20.01 44095 20100601 SE 19.82 19.96 19.2 19.2 44092 20100602 SE 19.36 19.85 19.15 19.85 35495 20100603 SE 19.81 20.16 19.74 20.11 43587 20100604 SE 19.81 19.94 19.27 19.43 44531 20100607 SE 19.51 19.69 19.23 19.23 42711 20100608 SE 19.31 19.79 19.09 19.75 42038 - ---- - -32198 20091013 STI 22.32 22.48 21.87 22.01 71332 20091014 STI 22.63 22.7 22.25 22.46 85875 20091015 STI 22.24 22.64 22.12 22.25 86742 20091016 STI 21.77 21.91 21.34 21.71 72978 20091019 STI 21.78 21.92 20.76 21.08 95714 20091020 STI 20.92 21.05 20.065 20.82 90348 20091021 STI 20.74 21.65 20.59 20.76 107471 20091022 STI 21.28 22.44 20.05 21.85 166971 20091023 STI 21.86 21.86 20.4 20.99 142372 20091026 STI 20.22 20.64 19.525 19.85 194922 20091027 STI 19.89 20.13 19 19.19 126039 20091028 STI 19.22 19.63 18.45 18.89 178465 20091105 STI 19.58 20.29 19.3 20.27 101250 20091106 STI 19.91 20.42 19.705 19.93 59097 20091109 STI 20.29 21.01 19.94 21 72906 20091110 STI 20.9 20.95 20.08 20.29 68517 20091111 STI 20.5 21.19 20.35 21.07 71218 20091112 STI 20.94 21.05 20.16 20.25 78097 20091113 STI 20.32 20.675 19.92 20.07 59979 20091116 STI 20.44 21.02 20.3 20.91 92001 20091117 STI 20.84 21.95 20.79 21.86 132427 20091118 STI 21.87 22.45 21.58 21.94 141117 20091119 STI 21.43 21.99 21.43 21.86 79169 20091120 STI 21.67 22.07 21.57 22.04 72183 20091123 STI 22.26 23.35 22.26 23.15 113380 20091124 STI 23.02 23.43 22.71 22.84 98120 20091125 STI 23.04 23.1 22.64 22.7 46342 20091127 STI 22 22.82 21.93 22.59 54733 20091130 STI 22.63 23.7 22.6 23.63 83508 20091201 STI 23.71 23.87 23.11 23.2 96050 20091202 STI 23.9 24.09 22.89 23.29 169930 20091203 STI 23.07 23.29 22.3 22.35 139493 20091204 STI 22.84 23.03 22.41 22.8 102003 20091207 STI 22.77 23.02 22.46 22.62 55146 20091208 STI 22.3 22.835 22.22 22.5 42810 20091209 STI 22.78 22.78 22.14 22.2 45791 20091210 STI 22.25 22.39 21.84 21.92 40213 20091211 STI 22 22.32 21.81 22.31 37210 20091214 STI 22.39 22.4 21.77 22.28 38291 20091215 STI 22.06 22.17 20.8 21 121690 20091216 STI 21.21 21.42 20.7 20.85 76363 20091217 STI 20.65 21.2 20.5 20.58 79218 20091218 STI 20.44 21.04 20.04 21.01 112786 20091221 STI 21.01 21.25 20.78 21.23 45653 20091222 STI 21.13 21.18 20.755 20.85 54239 20091223 STI 20.8 20.93 20.25 20.28 49888 20091224 STI 20.43 20.84 20.43 20.74 20084 20091228 STI 20.63 20.91 20.45 20.55 38008 20091229 STI 20.66 20.77 20.43 20.56 26649 20091230 STI 20.4 20.5 20.07 20.18 34989 20091231 STI 20.21 20.47 20.13 20.29 37847 20100104 STI 20.65 20.69 20.21 20.44 66692 20100105 STI 20.34 20.78 20.16 20.72 82866 20100106 STI 20.62 21.47 20.33 21.3 82254 20100107 STI 21.4 23.29 21.04 22.56 155751 20100108 STI 22.43 23.04 22.32 23.01 67147 20100111 STI 23.11 23.35 22.72 23.27 71801 20100112 STI 23.03 23.1 22.38 22.45 92286 20100113 STI 22.61 22.9 22.11 22.78 82769 20100114 STI 22.78 23.99 22.66 23.7 79620 20100115 STI 23.49 23.6 22.95 23.39 103370 20100119 STI 23.28 23.47 23 23.35 58518 20100120 STI 23.19 23.93 23.11 23.42 82590 20100121 STI 23.53 25.89 23.51 24.53 181097 20100122 STI 24.53 25.67 23.66 24.55 208862 20100125 STI 24.54 24.7 23.06 24 123743 20100126 STI 23.79 24.38 23.46 23.62 99194 20100127 STI 23.57 24.81 23.44 24.7 111976 20100128 STI 26.01 26.2 24.57 24.81 205298 20100129 STI 24.59 24.77 24.2 24.33 134315 20100201 STI 24.46 24.58 23.64 24.5 114885 20100202 STI 24.5 24.68 23.98 24.27 117490 20100203 STI 24 24.05 22.86 23.27 138748 20100204 STI 23.22 23.3 21.92 22 124939 20100205 STI 21.96 22.67 21.44 22.49 91577 20100208 STI 22.37 23.09 21.84 22.4 76619 20100209 STI 22.61 23.07 22.4 22.69 57734 20100210 STI 22.59 23.41 22.49 22.99 58197 20100211 STI 22.94 23 22.38 22.48 91056 20100212 STI 22.26 22.4 21.8 22.37 83465 20100216 STI 22.71 22.89 22.53 22.69 90097 20100217 STI 22.91 23.02 22.41 22.6 90225 20100218 STI 22.44 22.78 22.08 22.62 94972 20100219 STI 22.65 23.12 22.65 23.03 79526 20100222 STI 23.16 23.9 23.05 23.65 70166 20100223 STI 23.71 23.74 22.69 22.76 77764 20100224 STI 22.85 23.87 22.77 23.77 86976 20100225 STI 23.39 23.55 22.93 23.52 68414 20100226 STI 23.59 23.86 23.19 23.81 68493 20100301 STI 23.79 23.86 23.3 23.64 43873 20100302 STI 23.67 24.72 23.67 24.43 76578 20100303 STI 24.51 24.64 24.08 24.16 39229 20100304 STI 24.17 24.44 24 24.38 42616 20100305 STI 24.45 25.09 24.35 25.06 - ---- - -23442 20100604 RTN 52.2 52.52 51.3 51.47 30766 20100607 RTN 51.58 51.68 50.7 50.72 32138 20100608 RTN 50.69 51.05 49.74 50.47 37189 20100609 RTN 50.64 51.34 50.35 50.51 32029 20100610 RTN 51.11 51.73 50.86 51.5 26956 20100611 RTN 51.06 51.76 50.66 51.71 17185 20100614 RTN 52.05 52.27 51.36 51.4 21390 20100615 RTN 51.84 53.13 51.84 53.13 24913 20100616 RTN 52.86 53.21 52.7 52.85 25650 20100617 RTN 53.1 53.16 52.39 53.1 18275 20100618 RTN 53.28 53.33 52.765 53.25 23985 20100621 RTN 53.58 53.76 52.92 53.19 20511 20100622 RTN 52.94 53.47 52.07 52.18 16499 20100623 RTN 52.12 52.42 51.41 51.96 23443 20100624 RTN 51.73 51.98 50.64 50.8 22660 20100625 RTN 50.82 51 50.05 50.38 59237 20100628 RTN 50.57 51.02 50.17 50.59 19923 20100629 RTN 49.89 50.05 48.42 48.75 27417 20100630 RTN 48.77 49.04 48.31 48.39 31560 20100701 RTN 47.93 48.01 47.19 47.73 29313 20100702 RTN 47.91 48.15 47.26 47.58 19862 20100706 RTN 47.99 48.18 47.02 47.47 21912 20100707 RTN 47.46 48.86 47.36 48.81 20025 20100708 RTN 49.03 49.59 48.85 49.5 19972 20100709 RTN 49.58 49.58 48.495 48.81 19399 20100712 RTN 48.52 48.71 47.965 48.1 17517 20100713 RTN 48.4 48.78 48.08 48.33 34453 20100714 RTN 48.22 48.86 47.91 48.57 25640 20100715 RTN 49.07 49.3 48.26 49.02 32270 20100716 RTN 48.83 49.315 47.68 47.73 26359 20100719 RTN 48.07 48.4 47.76 48.03 22098 20100720 RTN 47.51 48.56 47.09 48.45 24972 20100721 RTN 48.86 48.86 47.85 48.14 20129 20100722 RTN 48.58 48.99 48.2 48.69 32936 20100723 RTN 48.85 49.31 48.5 49.06 36466 20100726 RTN 49.27 50 49.26 49.64 30194 20100727 RTN 49.33 49.59 48.12 48.31 45260 20100728 RTN 48.26 48.6 48.17 48.27 34044 20100729 RTN 47.14 47.97 46.64 46.67 50950 20100730 RTN 46.31 46.61 46 46.27 43443 20100802 RTN 46.98 46.99 46.15 46.89 33912 20100803 RTN 46.67 46.88 45.9 45.99 44059 20100804 RTN 46.05 46.48 45.83 46.34 34109 20100805 RTN 46.17 46.85 45.95 46.43 33540 20100806 RTN 45.98 46.47 45.8 46.14 27316 20100809 RTN 46.43 46.75 46.32 46.45 22437 20100810 RTN 46.13 46.53 45.64 46.3 31702 20100811 RTN 45.74 45.83 44.74 44.93 27013 20100812 RTN 44.47 44.83 44.23 44.59 28128 20100813 RTN 44.49 45.185 44.49 44.74 21342 20100816 RTN 44.47 45.07 44.24 44.76 26755 20100817 RTN 45.15 45.8 44.95 45.46 29334 20100819 RTN 44.93 44.93 43.8901 44.01 35605 20100820 RTN 43.62 43.88 43.16 43.75 40716 20090821 RX 13.41 13.87 13.31 13.81 22659 20090824 RX 13.95 14 13.75 13.85 18686 20090825 RX 13.99 14.15 13.88 13.98 20810 20090826 RX 13.98 14.13 13.9 14.05 20942 20090827 RX 14.07 14.11 13.54 14.02 22628 20090828 RX 14.14 14.16 13.745 13.94 24822 20090831 RX 13.93 13.94 13.77 13.86 21181 20090901 RX 13.89 13.9 13.4125 13.45 19459 20090902 RX 13.53 13.63 13.23 13.52 20830 20090903 RX 13.49 13.89 13.37 13.87 24394 20090904 RX 13.9 14.01 13.76 13.93 16446 20090909 RX 14.07 14.36 14.06 14.27 11508 20090910 RX 14.33 14.42 14.15 14.4 10256 20090911 RX 14.44 14.74 14.34 14.72 26367 20090914 RX 14.91 14.91 14.68 14.85 18035 20090915 RX 14.89 14.89 14.66 14.85 13642 20090916 RX 14.97 15.25 14.85 15.21 18676 20090917 RX 15.29 15.54 15.25 15.33 19037 20090918 RX 15.41 15.52 15.27 15.46 15799 20090921 RX 15.45 15.65 15.35 15.54 15821 20090922 RX 15.61 15.61 15.31 15.44 12790 20090923 RX 15.5 15.51 15.22 15.25 14313 20090924 RX 15.27 15.36 15.02 15.09 22270 20090925 RX 15.13 15.23 15 15.06 27927 20090928 RX 15.15 15.56 15.1 15.41 16191 20090929 RX 15.46 15.81 15.35 15.54 20831 20090930 RX 15.515 15.57 15.11 15.35 18035 20091001 RX 15.33 15.42 14.86 14.95 17192 20091002 RX 14.85 14.922 14.61 14.67 18706 20091005 RX 14.75 14.87 14.61 14.83 14849 20091006 RX 14.96 14.964 14.76 14.83 13768 20091007 RX 14.82 14.84 14.61 14.81 14816 20091008 RX 14.92 15.3 14.87 15.23 13972 20091009 RX 15.24 15.27 15.025 15.12 13098 20091012 RX 15.2 15.26 15.11 15.23 10702 20091013 RX 15.17 15.32 15.01 15.17 15656 20091014 RX 15.28 15.29 15.02 15.16 14604 20091015 RX 15.15 15.29 15.04 15.24 12034 20091016 RX 15.11 15.26 14.65 14.67 42990 20091019 RX 14.72 17.89 14.51 17.84 88321 20091020 RX 17.48 - ---- - -170361 20100723 Q 5.62 5.64 5.58 5.64 159942 20100726 Q 5.63 5.66 5.62 5.66 344700 20100727 Q 5.65 5.67 5.63 5.64 250897 20100728 Q 5.63 5.66 5.6 5.62 207357 20100729 Q 5.64 5.645 5.59 5.62 219909 20100730 Q 5.6 5.66 5.58 5.66 178534 20100802 Q 5.66 5.68 5.64 5.66 568576 20100803 Q 5.64 5.67 5.6254 5.65 209741 20100804 Q 5.66 5.71 5.64 5.7 352208 20100805 Q 5.64 5.69 5.63 5.64 328263 20100806 Q 5.6 5.69 5.6 5.69 291089 20100809 Q 5.7 5.72 5.66 5.7 209312 20100810 Q 5.68 5.73 5.65 5.69 289505 20100811 Q 5.66 5.67 5.63 5.64 264830 20100812 Q 5.63 5.66 5.62 5.62 359504 20100813 Q 5.66 5.7 5.65 5.69 281409 20100816 Q 5.67 5.7 5.66 5.69 185230 20100817 Q 5.69 5.7 5.65 5.7 302070 20100819 Q 5.66 5.67 5.64 5.66 203526 20100820 Q 5.64 5.69 5.63 5.65 268576 20090821 QCOM 47.49 47.49 46.63 47.29 207027 20090824 QCOM 46.87 47.5 46.86 47.41 116223 20090825 QCOM 47.28 47.85 46.88 46.99 214903 20090826 QCOM 47 47.78 46.76 47.53 144803 20090827 QCOM 47.4 47.57 46.8 47.25 107199 20090828 QCOM 47.91 48.2 46.94 47.22 119810 20090831 QCOM 46.94 47 45.99 46.42 158731 20090901 QCOM 46.02 46.72 45.05 45.35 192796 20090902 QCOM 44.98 45.81 44.68 45.42 143835 20090903 QCOM 45.12 45.3 44.13 45.02 313554 20090904 QCOM 45.02 45.97 44.75 45.72 146853 20090909 QCOM 45.83 46.54 45.21 46.22 222530 20090910 QCOM 46.11 46.75 45.89 46.65 142697 20090911 QCOM 46.65 46.71 45.92 46.61 104663 20090914 QCOM 46.16 46.48 45.8 46.23 119864 20090915 QCOM 46.07 46.13 45.64 45.75 154200 20090916 QCOM 45.83 45.93 44.94 45.71 207648 20090917 QCOM 45.45 45.65 44.87 45.02 175424 20090918 QCOM 45.33 45.39 44 44.46 308740 20090921 QCOM 44.08 44.99 44.01 44.87 146164 20090922 QCOM 44.93 44.99 44.33 44.59 147343 20090923 QCOM 44.56 44.91 44.18 44.23 178773 20090924 QCOM 44.41 44.86 44.18 44.66 190089 20090925 QCOM 44.55 45.13 44.3 44.7 194911 20090928 QCOM 45.08 46.35 45.02 45.97 184971 20090929 QCOM 45.98 46.03 45.25 45.5 158082 20090930 QCOM 45.74 45.83 44.51 44.98 202639 20091001 QCOM 44.51 44.64 42.5 42.7 319587 20091002 QCOM 42.33 42.62 41.22 41.44 347135 20091005 QCOM 41.62 42.29 41.34 41.94 177903 20091006 QCOM 42.26 43.4 42.21 42.62 245798 20091007 QCOM 42.42 42.66 42.02 42.18 153306 20091008 QCOM 42.58 42.68 41.37 41.45 244278 20091009 QCOM 41.45 41.77 40.5 41.7 346014 20091012 QCOM 41.76 42.01 41.19 41.54 137321 20091013 QCOM 41.62 41.84 41.08 41.29 154472 20091014 QCOM 41.88 42.36 41.61 42.23 230377 20091015 QCOM 42.08 42.48 41.88 42.45 158838 20091016 QCOM 42.56 42.56 41.32 41.96 227462 20091019 QCOM 42.07 42.34 41.56 42.06 131269 20091020 QCOM 41.82 41.95 41.1 41.309 174238 20091021 QCOM 41.38 41.95 41.26 41.41 175781 20091022 QCOM 40.715 41.24 40.15 41.08 253526 20091023 QCOM 40.86 41.11 40.53 40.7 163685 20091026 QCOM 40.52 41.46 40.37 40.68 170759 20091027 QCOM 40.8 41.32 40.69 41 150875 20091028 QCOM 41.14 41.98 41 41.63 226018 20091105 QCOM 43.05 43.88 42.92 43.85 365388 20091106 QCOM 43.54 43.97 43.4 43.9 159936 20091109 QCOM 44.15 45 44.15 44.75 178268 20091110 QCOM 44.75 44.75 44.29 44.3517 125146 20091111 QCOM 44.37 44.75 44.35 44.66 156888 20091113 QCOM 45.28 46 45.24 45.77 164080 20091116 QCOM 45.85 46.25 45.29 45.51 133905 20091117 QCOM 45.52 45.99 45.46 45.99 103395 20091118 QCOM 45.84 45.93 45.2 45.49 131706 20091119 QCOM 45.11 45.36 44.55 45.09 149178 20091120 QCOM 44.83 45.25 44.76 45.1 125581 20091123 QCOM 45.25 45.9 45.25 45.55 94031 20091124 QCOM 45.86 46 45.38 45.56 111063 20091125 QCOM 45.74 45.84 45.34 45.44 83288 20091127 QCOM 44.74 45.39 44.69 44.99 61718 20091130 QCOM 44.76 45.07 44.32 45 113602 20091201 QCOM 45.05 45.47 44.88 45.06 141412 20091202 QCOM 45.21 45.55 44.9 45.06 125816 20091203 QCOM 45.13 45.28 44.6 44.63 107500 20091204 QCOM 45.02 45.68 44.68 45.16 146683 20091207 QCOM 45.14 45.42 44.8 44.89 84857 20091208 QCOM 44.74 45.2 44.13 44.59 131535 20091209 QCOM 44.35 44.87 44.18 44.77 114208 20091210 QCOM 45.01 45.79 44.95 45.56 148922 20091211 QCOM 45.79 45.88 44.73 44.9 164932 20091214 QCOM 45.14 45.22 44.58 44.67 117553 20091215 - ---- - -28.15 166099 20090921 HAL 27.33 27.87 27.19 27.45 95075 20090922 HAL 27.89 28.35 27.63 28.32 90518 20090923 HAL 28.46 28.58 27.33 27.35 110533 20090924 HAL 27.43 27.49 26.57 26.77 116792 20090925 HAL 26.42 26.98 26.19 26.74 112492 20090928 HAL 26.84 27.38 26.63 27.29 78201 20090929 HAL 27.16 27.55 26.89 27.31 90645 20090930 HAL 27.47 27.51 26.61 27.12 119581 20091001 HAL 27.12 27.25 26.34 26.4 169332 20091002 HAL 25.57 26.06 25.5 25.74 125385 20091005 HAL 25.67 26.65 25.64 26.48 98325 20091006 HAL 26.93 27.44 26.65 26.86 134913 20091007 HAL 26.85 28.08 26.835 28.02 167020 20091008 HAL 28.32 28.89 28.03 28.8 182929 20091009 HAL 28.64 28.79 28 28.22 109184 20091012 HAL 28.6 28.99 28.45 28.97 139014 20091013 HAL 29 29.08 28.1475 28.47 137176 20091014 HAL 28.99 29.26 28.72 29.19 122333 20091015 HAL 28.94 30 28.94 29.85 305477 20091016 HAL 30.13 31.27 29.94 30.4 311755 20091019 HAL 30.9 31.21 30.57 31.05 207968 20091020 HAL 31.25 31.65 30.23 30.8 178764 20091021 HAL 30.56 31.95 30.4 31 184802 20091022 HAL 30.86 31.6 30.38 31.41 115873 20091023 HAL 31.51 31.51 29.86 30.21 169383 20091026 HAL 30.3 31.05 29.47 29.7 147815 20091027 HAL 29.74 30.38 29.33 30.04 164222 20091028 HAL 29.73 29.9 28.78 28.94 220462 20091105 HAL 30.45 30.78 30.265 30.55 128545 20091106 HAL 30.2 31.58 30.2 31.03 159656 20091109 HAL 31.83 31.98 31.41 31.63 117598 20091110 HAL 31.44 31.88 30.825 31.47 101953 20091111 HAL 31.81 32 31.1 31.42 108609 20091112 HAL 31.22 31.32 30.12 30.3 159174 20091113 HAL 30.34 30.98 29.87 30.71 122454 20091116 HAL 30.92 32 30.81 31.72 143128 20091117 HAL 31.58 31.96 31.22 31.75 87904 20091118 HAL 31.95 31.95 31.19 31.69 103807 20091119 HAL 31.4 31.43 30.22 30.44 127241 20091120 HAL 30.22 30.46 29.72 29.88 154943 20091123 HAL 30.63 30.89 30.21 30.44 113442 20091124 HAL 30.26 30.775 29.96 30.46 98575 20091125 HAL 29.95 30.35 29.3 30.21 184083 20091127 HAL 28.99 29.43 28.28 29.09 88341 20091130 HAL 28.89 29.49 28.78 29.36 144287 20091201 HAL 29.63 29.87 29.26 29.35 139419 20091202 HAL 29.24 29.565 28.75 28.95 117806 20091203 HAL 28.75 28.86 27.98 28.06 144283 20091204 HAL 28.54 28.96 27.4 27.81 133015 20091207 HAL 27.57 28.24 27.5 27.7 90651 20091208 HAL 27.35 27.3999 26.7 26.8 180935 20091209 HAL 26.65 27.61 26.55 27.46 175548 20091210 HAL 27.58 28.4 27.58 28.17 149279 20091211 HAL 28 28.55 27.88 28.11 116694 20091214 HAL 28.58 28.95 28.5 28.64 97616 20091215 HAL 28.6 29.5 28.6 29.12 119779 20091216 HAL 29.35 30.13 29.29 29.6 115662 20091217 HAL 29.41 30.22 29.3 30.08 200575 20091218 HAL 30.38 30.39 29.48 29.62 168377 20091221 HAL 29.88 30.66 29.88 30.28 114239 20091222 HAL 30.21 30.5 30.1 30.16 82875 20091223 HAL 30.44 30.55 30.3 30.46 72363 20091224 HAL 30.5 30.64 30.19 30.27 33859 20091228 HAL 30.32 30.64 30.17 30.31 54015 20091229 HAL 30.4 30.53 29.54 29.64 93242 20091230 HAL 29.62 30.05 29.35 29.97 74711 20091231 HAL 30.31 30.52 29.99 30.09 76795 20100104 HAL 30.72 31.34 30.655 31.25 115715 20100105 HAL 31.21 31.83 30.99 31.65 189901 20100106 HAL 31.74 32.59 31.64 32.4 157207 20100107 HAL 32.31 32.52 31.92 32.48 90001 20100108 HAL 32.95 34.14 32.49 34.12 230147 20100111 HAL 34.71 34.87 33.38 33.78 159442 20100112 HAL 33.17 33.73 32.86 33.29 157395 20100113 HAL 33.35 34.21 33.17 34.05 138856 20100114 HAL 34.08 34.64 33.7 34.31 120079 20100115 HAL 34.19 34.29 33.47 34.03 119671 20100119 HAL 33.85 34.72 33.85 34.6 120180 20100120 HAL 34.1 34.24 33.01 33.27 174637 20100121 HAL 33.25 33.52 32.5 32.53 208255 20100122 HAL 32.27 32.47 31.05 31.15 215796 20100125 HAL 29.69 31.5 29.52 31.07 298149 20100126 HAL 30.83 31.495 30.31 30.88 189314 20100127 HAL 30.73 30.87 29.4 30.41 194106 20100128 HAL 30.83 30.83 29.36 29.65 168865 20100129 HAL 29.98 30.66 29.01 29.21 181972 20100201 HAL 29.57 30.7 29.53 30.65 138216 20100202 HAL 30.86 31.5 30.43 30.76 164140 20100203 HAL 30.71 31.21 30.155 30.36 110901 20100204 HAL 29.97 29.97 28.71 28.86 179608 20100205 HAL 28.81 29.26 27.71 28.29 220972 20100208 HAL 28.33 29.02 28.05 28.1 163367 20100209 - ---- - -20091222 NOVL 4.1 4.2 4.09 4.18 17176 20091223 NOVL 4.17 4.18 4.09 4.13 24114 20091224 NOVL 4.15 4.2 4.13 4.17 10902 20091228 NOVL 4.15 4.18 4.07 4.09 44998 20091229 NOVL 4.09 4.16 4.08 4.13 43146 20091230 NOVL 4.12 4.19 4.11 4.14 31424 20091231 NOVL 4.17 4.24 4.15 4.15 24024 20100104 NOVL 4.2 4.25 4.13 4.2 48152 20100105 NOVL 4.24 4.47 4.21 4.44 95492 20100106 NOVL 4.45 4.65 4.41 4.62 91401 20100107 NOVL 4.57 4.6 4.53 4.6 64070 20100108 NOVL 4.53 4.62 4.5 4.62 54857 20100111 NOVL 4.62 4.685 4.58 4.66 55207 20100112 NOVL 4.63 4.69 4.61 4.64 46377 20100113 NOVL 4.64 4.75 4.63 4.73 54307 20100114 NOVL 4.73 4.76 4.68 4.75 43913 20100115 NOVL 4.77 4.77 4.58 4.73 73207 20100119 NOVL 4.7 4.81 4.69 4.79 62936 20100120 NOVL 4.73 4.79 4.65 4.76 54985 20100121 NOVL 4.8 4.84 4.69 4.77 53582 20100122 NOVL 4.71 4.7895 4.62 4.64 48596 20100125 NOVL 4.7 4.7 4.65 4.66 31578 20100126 NOVL 4.65 4.71 4.63 4.68 33425 20100127 NOVL 4.65 4.68 4.6 4.66 27742 20100128 NOVL 4.66 4.65 4.52 4.58 43652 20100129 NOVL 4.61 4.65 4.47 4.47 60289 20100201 NOVL 4.61 4.62 4.43 4.57 58309 20100202 NOVL 4.57 4.92 4.55 4.87 91393 20100203 NOVL 4.85 4.85 4.74 4.82 53940 20100204 NOVL 4.74 4.8 4.66 4.68 48539 20100205 NOVL 4.67 4.76 4.64 4.72 40177 20100208 NOVL 4.73 4.88 4.6 4.74 50362 20100209 NOVL 4.78 4.9 4.71 4.84 43748 20100210 NOVL 4.82 4.84 4.73 4.79 36108 20100211 NOVL 4.79 4.82 4.7 4.76 38208 20100212 NOVL 4.7 4.87 4.69 4.75 45334 20100216 NOVL 4.81 4.89 4.76 4.86 26946 20100217 NOVL 4.88 4.9 4.81 4.85 34651 20100218 NOVL 4.88 4.97 4.85 4.96 28955 20100219 NOVL 4.94 5.05 4.9 4.93 41449 20100222 NOVL 4.92 4.97 4.87 4.92 43105 20100223 NOVL 4.88 4.93 4.83 4.84 21651 20100224 NOVL 4.85 4.89 4.82 4.86 24079 20100225 NOVL 4.78 4.81 4.69 4.81 46306 20100226 NOVL 4.73 4.76 4.66 4.7 77913 20100301 NOVL 4.71 4.82 4.65 4.8 52204 20100302 NOVL 4.8 4.86 4.73 4.75 115607 20100303 NOVL 6.07 6.15 5.93 6.08 1413344 20100304 NOVL 6.06 6.11 6.01 6.01 381655 20100305 NOVL 6.04 6.06 5.88 5.91 157709 20100308 NOVL 5.86 5.9898 5.76 5.81 144396 20100309 NOVL 5.95 6.02 5.81 5.85 159448 20100310 NOVL 5.87 5.89 5.78 5.81 72156 20100311 NOVL 5.81 5.89 5.77 5.8 106700 20100312 NOVL 5.82 5.85 5.69 5.72 148171 20100315 NOVL 5.72 5.84 5.7 5.8 53324 20100316 NOVL 5.78 5.81 5.73 5.78 69698 20100317 NOVL 5.77 5.815 5.72 5.77 87239 20100318 NOVL 5.77 5.79 5.7 5.72 54166 20100319 NOVL 5.73 5.77 5.6378 5.64 64741 20100322 NOVL 5.9 5.95 5.83 5.89 101742 20100323 NOVL 5.89 5.94 5.87 5.92 34819 20100324 NOVL 5.92 5.93 5.87 5.87 37531 20100325 NOVL 5.89 5.95 5.86 5.86 35542 20100326 NOVL 5.9 5.91 5.81 5.86 40500 20100329 NOVL 5.86 5.86 5.71 5.75 57594 20100330 NOVL 5.73 5.89 5.67 5.84 125821 20100331 NOVL 5.84 6.1 5.8 6 113256 20100401 NOVL 6.04 6.12 5.94 6.07 99255 20100405 NOVL 6.05 6.1 6 6.02 30362 20100406 NOVL 6.05 6.06 5.86 5.91 53695 20100407 NOVL 5.9 5.96 5.86 5.88 42697 20100408 NOVL 5.88 5.9 5.84 5.86 42299 20100409 NOVL 5.86 5.915 5.84 5.89 21702 20100412 NOVL 5.88 5.915 5.8 5.81 70082 20100413 NOVL 5.85 5.88 5.775 5.79 38044 20100414 NOVL 5.81 5.91 5.81 5.89 19017 20100415 NOVL 5.89 5.91 5.76 5.79 31558 20100416 NOVL 5.79 5.82 5.75 5.76 40613 20100419 NOVL 5.77 5.8 5.74 5.74 24229 20100420 NOVL 5.77 5.79 5.74 5.76 14604 20100421 NOVL 5.77 5.85 5.76 5.78 14085 20100422 NOVL 5.78 5.82 5.7592 5.78 22963 20100423 NOVL 5.8 5.82 5.75 5.78 26423 20100426 NOVL 5.79 5.87 5.76 5.84 26034 20100427 NOVL 5.81 5.88 5.75 5.75 29947 20100428 NOVL 5.75 5.79 5.7 5.71 42575 20100429 NOVL 5.73 5.76 5.69 5.74 20818 20100430 NOVL 5.76 5.76 5.61 5.6375 39188 20100503 NOVL 5.67 5.775 5.67 5.77 18675 20100504 NOVL 5.71 5.72 5.63 5.66 27348 20100505 NOVL 5.64 5.65 5.54 5.6 33272 20100506 NOVL 5.6 5.66 5.06 5.36 93956 20100507 NOVL 5.36 5.44 5.06 5.25 86771 20100510 NOVL 5.47 5.52 5.31 5.43 28336 20100511 NOVL 5.4 5.845 5.36 5.77 83804 20100512 NOVL 5.8 5.83 5.63 5.75 56592 20100513 NOVL 5.73 6.06 5.715 5.86 78830 20100514 NOVL 5.81 5.905 5.75 5.84 53196 20100517 NOVL 5.81 5.91 5.74 5.88 66451 20100518 NOVL 5.9 - ---- - -12690 20100312 AEE 25.82 25.89 25.5 25.51 11751 20100315 AEE 25.49 25.5999 25.35 25.49 16995 20100316 AEE 25.49 25.58 25.4 25.5 14483 20100317 AEE 25.5 25.7 25.43 25.67 10146 20100318 AEE 25.69 26 25.67 26 16273 20100319 AEE 26.03 26.2 25.83 26.04 29121 20100322 AEE 25.95 25.97 25.65 25.82 18658 20100323 AEE 25.79 25.9 25.73 25.88 9368 20100324 AEE 25.76 25.89 25.49 25.5 13366 20100325 AEE 25.57 25.68 25.28 25.29 17306 20100326 AEE 25.45 25.74 25.32 25.63 23685 20100329 AEE 25.74 25.99 25.61 25.93 15293 20100330 AEE 25.99 26.18 25.88 26.09 12188 20100331 AEE 26.11 26.14 25.86 26.08 18872 20100401 AEE 26.2 26.45 26.19 26.45 12585 20100405 AEE 26.55 26.55 26.35 26.48 17808 20100406 AEE 26.39 26.65 26.32 26.65 10517 20100407 AEE 26.64 26.72 26.4 26.46 13995 20100408 AEE 26.42 26.43 26.19 26.27 12066 20100409 AEE 26.26 26.51 26.18 26.51 9590 20100412 AEE 26.51 26.7799 26.51 26.73 9501 20100413 AEE 26.71 26.74 26.47 26.59 11040 20100414 AEE 26.56 26.66 26.41 26.65 12394 20100415 AEE 26.55 26.65 26.28 26.65 13903 20100416 AEE 26.61 26.75 26.31 26.35 17340 20100419 AEE 26.27 26.4 26.15 26.3 13753 20100420 AEE 26.45 26.7 26.37 26.7 12970 20100421 AEE 26.75 26.92 26.66 26.91 14180 20100422 AEE 26.9 26.9 26.45 26.64 19305 20100423 AEE 26.62 26.82 26.45 26.82 12651 20100426 AEE 26.86 26.86 26.63 26.68 9641 20100427 AEE 26.52 26.57 26.13 26.16 15155 20100428 AEE 26.23 26.56 26.02 26.47 16273 20100429 AEE 26.55 26.85 26.34 26.36 23147 20100430 AEE 26.04 26.29 25.11 25.96 41324 20100503 AEE 25.93 26.035 25.62 25.77 22902 20100504 AEE 25.63 25.67 25.35 25.64 25108 20100505 AEE 25.19 25.81 25.17 25.49 24213 20100506 AEE 25.45 25.48 23.09 24.66 42978 20100507 AEE 24.75 24.78 23.8 24.2 38021 20100510 AEE 24.96 25.21 24.69 25.2 23775 20100511 AEE 25.01 25.5 25.01 25.24 21023 20100512 AEE 25.19 25.54 25.05 25.5 16962 20100513 AEE 25.5 25.62 25.2 25.27 15532 20100514 AEE 25.15 25.3 24.82 25.09 18689 20100517 AEE 25.19 25.26 24.78 25.16 13636 20100518 AEE 25.31 25.65 24.98 25.03 16966 20100519 AEE 24.94 25.0396 24.42 24.7 17994 20100520 AEE 24.33 24.63 24 24.14 32185 20100521 AEE 23.88 24.19 23.75 24.14 36566 20100524 AEE 23.94 24.43 23.84 23.96 18531 20100525 AEE 23.52 23.78 23.14 23.74 31810 20100526 AEE 23.94 24.3 23.66 23.91 24438 20100527 AEE 24.3 24.48 24.15 24.41 14364 20100528 AEE 24.45 24.92 24.24 24.66 34528 20100601 AEE 24.47 24.51 23.95 23.97 23705 20100602 AEE 24.05 24.59 24.03 24.56 25685 20100603 AEE 24.6 24.93 24.56 24.86 19967 20100604 AEE 24.49 24.64 24.05 24.09 28395 20100607 AEE 23.68 24.145 23.66 23.89 25270 20100608 AEE 23.96 24.02 23.69 23.99 21296 20100609 AEE 24.11 24.17 23.73 23.8 17843 20100610 AEE 24.05 24.26 23.885 24.25 22849 20100611 AEE 24.08 24.22 23.84 24.12 16766 20100614 AEE 24.16 24.34 24.13 24.16 12194 20100615 AEE 24.33 24.89 24.33 24.87 19993 20100616 AEE 24.71 25.41 24.71 25.22 26142 20100617 AEE 25.3 25.56 25.08 25.56 15645 20100618 AEE 25.54 25.61 25.43 25.54 18660 20100621 AEE 25.71 25.77 25.24 25.32 12377 20100622 AEE 25.29 25.4 24.59 24.64 17510 20100623 AEE 24.68 24.71 24.19 24.32 12042 20100624 AEE 24.28 24.53 24.18 24.22 12468 20100625 AEE 24.19 24.4 24 24.26 16576 20100628 AEE 24.41 24.59 24.21 24.45 8590 20100629 AEE 24.25 24.26 23.8 23.93 21100 20100630 AEE 23.95 24.28 23.72 23.77 20832 20100701 AEE 23.82 23.83 23.45 23.59 19881 20100702 AEE 23.63 23.85 23.59 23.68 11207 20100706 AEE 23.84 24.22 23.725 23.96 15010 20100707 AEE 24.02 24.69 23.99 24.69 12926 20100708 AEE 24.83 24.88 24.56 24.8 18438 20100709 AEE 24.77 24.9 24.47 24.9 12768 20100712 AEE 24.86 25 24.71 24.93 7835 20100713 AEE 25.01 25.27 24.915 25.07 10674 20100714 AEE 24.96 25.09 24.8 25.04 16158 20100715 AEE 24.94 25.13 24.75 25.08 14947 20100716 AEE 24.96 25.07 24.57 24.6 15807 20100719 AEE 24.71 25.27 24.71 25.14 15978 20100720 AEE 24.96 25.03 24.62 25.02 25252 20100721 AEE 25.09 25.09 24.52 24.68 13443 20100722 AEE 24.9 25.23 24.88 25.07 14903 20100723 AEE 25.12 25.42 24.85 25.29 16726 20100726 AEE 25.33 25.67 25.3006 25.65 12300 - ---- - -18237 20091208 FHN 13.85 14.27 13.83 14.07 25784 20091209 FHN 13.97 14.2425 13.825 13.94 25698 20091210 FHN 14 14.01 13.71 13.85 23193 20091211 FHN 13.71 13.97 13.6 13.66 29110 20091214 FHN 13.71 14.25 13.62 13.9 37793 20091215 FHN 13.53 13.825 13.48 13.54 79448 20091216 FHN 13.65 13.66 13.32 13.49 39873 20091217 FHN 13.38 13.66 13.36 13.45 26156 20091218 FHN 13.41 13.46 13.3 13.45 34224 20091221 FHN 13.59 13.82 13.5 13.79 20483 20091222 FHN 13.81 13.9101 13.68 13.74 23458 20091223 FHN 13.79 13.83 13.55 13.56 12609 20091224 FHN 13.61 13.7 13.56 13.69 4640 20091228 FHN 13.62 13.78 13.4 13.47 9713 20091229 FHN 13.5 13.59 13.36 13.44 10419 20091230 FHN 13.36 13.54 13.35 13.5 14746 20091231 FHN 13.48 13.58 13.4 13.4 13677 20100104 FHN 13.48 13.57 13.32 13.4 25890 20100105 FHN 13.37 13.52 13.33 13.47 20624 20100106 FHN 13.46 14.04 13.43 13.85 40722 20100107 FHN 13.85 14.25 13.72 14.19 45616 20100108 FHN 14.1 14.2525 13.98 14.23 30999 20100111 FHN 14.34 14.34 13.94 14.11 16690 20100112 FHN 14.01 14.195 13.75 13.81 23358 20100113 FHN 13.69 14.19 13.58 13.94 30953 20100114 FHN 13.93 14.2312 13.89 14.1 27892 20100115 FHN 13.99 14.01 13.56 13.63 57310 20100119 FHN 13.45 14.09 13.08 13.35 115204 20100120 FHN 13.11 13.7 13.07 13.5 56833 20100121 FHN 13.46 14.01 13.46 13.59 64888 20100122 FHN 13.53 13.68 13.2 13.32 49546 20100125 FHN 13.39 13.54 13.08 13.22 30136 20100126 FHN 13.13 13.34 12.8 12.85 36996 20100127 FHN 12.88 13.28 12.83 13.24 40496 20100128 FHN 13.35 13.42 13.01 13.04 25062 20100129 FHN 13.12 13.16 12.85 12.95 37662 20100201 FHN 12.73 13.05 12.67 12.77 39004 20100202 FHN 12.73 12.85 12.54 12.75 33772 20100203 FHN 12.64 12.69 12.5 12.56 35223 20100204 FHN 12.51 12.72 12.19 12.44 51419 20100205 FHN 12.38 12.74 12.35 12.62 46126 20100208 FHN 12.63 12.86 12.4501 12.57 28246 20100209 FHN 12.69 12.91 12.64 12.82 30596 20100210 FHN 12.76 13.24 12.71 13.16 45619 20100211 FHN 13.16 13.2 12.78 12.88 34892 20100212 FHN 13.13 13.22 12.86 13.03 47995 20100216 FHN 13.1 13.19 12.96 13.06 29632 20100217 FHN 13.15 13.22 12.97 13.05 21245 20100218 FHN 13 13.08 12.93 12.96 18741 20100219 FHN 12.93 13 12.77 12.91 29879 20100222 FHN 12.97 13.14 12.91 13.06 28046 20100223 FHN 13.02 13.06 12.72 12.72 23083 20100224 FHN 12.72 12.93 12.71 12.81 37012 20100225 FHN 12.68 12.78 12.59 12.74 23376 20100226 FHN 12.76 12.88 12.67 12.8 22038 20100301 FHN 12.79 12.79 12.58 12.72 14689 20100302 FHN 12.72 13.05 12.72 12.79 19275 20100303 FHN 12.77 12.96 12.75 12.89 19603 20100304 FHN 12.89 13.26 12.83 13.23 26134 20100305 FHN 13.36 13.54 13.23 13.51 27884 20100308 FHN 13.49 13.74 13.45 13.56 19053 20100309 FHN 13.52 13.52 13.24 13.27 16431 20100310 FHN 13.24 13.34 13.12 13.26 37847 20100311 FHN 13.22 13.59 13.21 13.59 15442 20100312 FHN 13.68 13.7 13.33 13.39 13808 20100315 FHN 13.33 13.38 13.16 13.21 20748 20100316 FHN 13.21 13.44 13.14 13.43 15895 20100317 FHN 13.46 13.95 13.42 13.93 39025 20100318 FHN 13.91 14.31 13.83 14.26 60976 20100319 FHN 14.36 14.61 14.26 14.44 64876 20100322 FHN 13.9 14.31 13.8 14.14 42566 20100323 FHN 14.14 14.17 13.85 14.16 21926 20100324 FHN 14.14 14.24 14.04 14.12 13744 20100325 FHN 13.93 14.22 13.86 13.86 37423 20100326 FHN 14.26 14.39 14.01 14.05 90849 20100329 FHN 14.25 14.26 14 14.07 24677 20100330 FHN 14.09 14.14 13.95 13.97 16123 20100331 FHN 13.92 14.2 13.9 14.05 23628 20100401 FHN 14.13 14.27 14.05 14.27 14996 20100405 FHN 14.23 14.46 14.04 14.46 20737 20100406 FHN 14.4 14.7 14.16 14.66 43594 20100407 FHN 14.7 14.74 14.41 14.72 37383 20100408 FHN 14.75 15 14.6 14.87 27632 20100409 FHN 14.85 15.05 14.81 15.02 21569 20100412 FHN 15.13 15.36 14.955 15.03 42914 20100413 FHN 15.07 15.07 14.64 14.96 37628 20100414 FHN 15.13 15.57 14.99 15.55 37962 20100415 FHN 15.65 15.86 15.26 15.32 53376 20100416 FHN 14.72 14.72 13.85 14.02 158260 20100419 FHN 13.8 14.08 13.67 14.04 64605 20100420 FHN 14.16 14.36 13.93 14.28 47134 20100421 FHN 14.31 14.83 14.26 14.47 52504 20100422 FHN 14.35 14.735 14.25 14.7 26332 20100423 FHN 14.68 14.84 - ---- - -63029 20091201 IBM 127.29 128.39 126.85 127.94 65785 20091202 IBM 127.32 128.39 127.16 127.21 45996 20091203 IBM 127.6 128.47 127.25 127.55 57599 20091204 IBM 128.4 128.9 126 127.25 70689 20091207 IBM 126.88 127.53 126.59 127.04 41446 20091208 IBM 126.97 127.35 126.16 126.8 53514 20091209 IBM 126.7 128.39 126.11 128.39 60719 20091210 IBM 128.13 129.47 128.09 129.34 70779 20091211 IBM 129.01 129.77 128.71 129.68 65992 20091214 IBM 129.65 129.98 129.6 129.93 52021 20091215 IBM 129.46 129.86 127.94 128.49 80333 20091216 IBM 128.74 129.6 128.35 128.71 63727 20091217 IBM 128 128.56 127.12 127.4 59104 20091218 IBM 127.97 128.39 127 127.91 91066 20091221 IBM 127.8 128.94 127.68 128.65 47751 20091222 IBM 129.41 129.98 129.19 129.93 55356 20091223 IBM 129.7 130 129.3 130 41291 20091224 IBM 129.89 130.57 129.48 130.57 42650 20091228 IBM 130.99 132.31 130.72 132.31 58010 20091229 IBM 132.28 132.37 131.8 131.85 41847 20091230 IBM 131.23 132.68 130.68 132.57 38672 20091231 IBM 132.41 132.85 130.75 130.9 42251 20100104 IBM 131.18 132.97 130.85 132.45 61558 20100105 IBM 131.68 131.85 130.1 130.85 68424 20100106 IBM 130.68 131.49 129.81 130 56052 20100107 IBM 129.87 130.25 128.91 129.55 58405 20100108 IBM 129.07 130.9199 129.05 130.85 41971 20100111 IBM 131.06 131.06 128.67 129.48 57311 20100112 IBM 129.03 131.33 129 130.51 80833 20100113 IBM 130.39 131.12 129.16 130.23 64583 20100114 IBM 130.55 132.71 129.91 132.31 71145 20100115 IBM 132.03 132.89 131.089 131.78 85023 20100119 IBM 131.63 134.25 131.56 134.14 139161 20100120 IBM 130.46 131.15 128.95 130.25 152018 20100121 IBM 130.47 130.69 128.06 129 96086 20100122 IBM 128.67 128.89 125.37 125.5 100893 20100125 IBM 126.33 126.895 125.71 126.12 57389 20100126 IBM 125.92 127.75 125.41 125.75 71366 20100127 IBM 125.82 126.96 125.04 126.33 87194 20100128 IBM 127.03 127.04 123.05 123.75 96228 20100129 IBM 124.32 125 121.9 122.39 115723 20100201 IBM 123.23 124.95 122.78 124.67 72498 20100202 IBM 125.03 125.81 123.95 125.53 59001 20100203 IBM 125.16 126.07 125.07 125.66 41779 20100204 IBM 125.19 125.44 122.9 123 91299 20100205 IBM 123.04 123.72 121.83 123.52 86180 20100208 IBM 123.15 123.22 121.74 121.88 57193 20100209 IBM 122.65 124.2 122.46 123.21 60449 20100210 IBM 122.94 123.65 122.21 122.81 52192 20100211 IBM 122.58 124.2 122.06 123.73 50910 20100212 IBM 123.01 124.05 121.61 124 80182 20100216 IBM 124.91 125.23 124.11 125.23 67772 20100217 IBM 125.5 126.53 125.21 126.33 58273 20100218 IBM 126.13 128 126 127.81 55275 20100219 IBM 127.35 128.06 126.8724 127.19 63036 20100222 IBM 127.3 127.43 126.31 126.85 38080 20100223 IBM 126.48 127.66 126 126.46 45943 20100224 IBM 127.02 128.27 126.81 127.59 47821 20100225 IBM 126.06 127.24 125.57 127.07 56587 20100226 IBM 127.01 128 126.74 127.16 47841 20100301 IBM 127.5 128.83 127.47 128.57 45777 20100302 IBM 128.7 129.09 127.13 127.42 60134 20100303 IBM 127.73 128.02 126.68 126.88 63899 20100304 IBM 127.07 127.07 125.47 126.72 60323 20100305 IBM 127.17 127.55 127.04 127.25 61404 20100308 IBM 127.06 127.5 126.36 126.41 61995 20100309 IBM 126.27 126.29 125.2 125.55 75293 20100310 IBM 125.985 126.36 125.21 125.62 69175 20100311 IBM 125.71 127.81 125.71 127.6 79294 20100312 IBM 127.9 128.37 127.51 127.94 51700 20100315 IBM 127.4 128.34 127.28 127.83 45440 20100316 IBM 128 128.88 127.45 128.67 61350 20100317 IBM 128.9 128.93 127.36 127.76 63489 20100318 IBM 127.6 128.75 127.45 128.38 49546 20100319 IBM 128.84 128.93 126.78 127.71 107442 20100322 IBM 127.11 128.39 126.57 127.98 56518 20100323 IBM 127.94 129.43 127.64 129.37 59792 20100324 IBM 128.67 129.95 128.47 128.53 66692 20100325 IBM 129.41 130.73 129.13 129.24 76053 20100326 IBM 128.93 129.78 128.7205 129.26 55507 20100329 IBM 129.3 129.95 128.26 128.59 46432 20100330 IBM 128.9 129.13 128.25 128.77 34265 20100331 IBM 128.23 128.75 127.65 128.25 49047 20100401 IBM 128.95 129.31 127.55 128.25 49806 20100405 IBM 128.38 129.8 128.14 129.35 41188 20100406 IBM 128.68 129.3 128.05 128.93 39264 20100407 IBM 128.53 - ---- - -19.48 50710 20090918 WU 19.62 19.62 19.41 19.56 62050 20090921 WU 19.45 19.7 19.26 19.49 51522 20090922 WU 19.63 20.64 19.53 20.56 89045 20090923 WU 20.61 20.61 19.59 19.59 85569 20090924 WU 19.69 19.84 19.37 19.4 47623 20090925 WU 19.32 19.53 19 19.08 42077 20090928 WU 19.17 19.73 19.07 19.73 33756 20090929 WU 19.71 19.85 19.22 19.26 59241 20090930 WU 19.33 19.36 18.71 18.92 79065 20091001 WU 18.83 19.03 18.42 18.45 61213 20091002 WU 18.31 18.47 18.13 18.17 49927 20091005 WU 18.3 18.31 18.07 18.16 64763 20091006 WU 18.32 18.87 18.27 18.77 78295 20091007 WU 18.64 18.82 18.47 18.66 44028 20091008 WU 18.81 19.07 18.75 18.96 35376 20091009 WU 18.94 19.1 18.82 19.06 34513 20091012 WU 19.08 19.27 19.06 19.17 26412 20091013 WU 19.28 19.29 18.89 19.2 49609 20091014 WU 19.41 19.93 19.29 19.83 54463 20091015 WU 19.74 19.91 19.58 19.86 47946 20091016 WU 19.74 19.95 19.27 19.78 43661 20091019 WU 19.77 20.07 19.53 19.68 68647 20091020 WU 19.82 20.04 19.4 19.61 72381 20091021 WU 19.22 19.74 18.83 19.16 76348 20091022 WU 19.1 19.4 18.67 19.32 54314 20091023 WU 19.29 19.29 18.74 18.79 46569 20091026 WU 18.79 19.25 18.63 18.83 40931 20091027 WU 18.91 19.11 18.51 18.67 52711 20091028 WU 18.57 18.72 18.19 18.21 51885 20091105 WU 18.6 18.96 18.53 18.96 29864 20091106 WU 18.75 18.91 18.55 18.81 42169 20091109 WU 19 19.53 18.82 19.51 43245 20091110 WU 19.44 19.72 19.38 19.64 36813 20091111 WU 19.73 19.75 19.37 19.58 32600 20091112 WU 19.59 19.72 19.27 19.32 35378 20091113 WU 19.32 19.535 19.14 19.44 26443 20091116 WU 19.54 20.09 19.53 20.02 52549 20091117 WU 19.8 19.89 19.35 19.82 42768 20091118 WU 19.72 19.85 19.46 19.67 27452 20091119 WU 18.99 19.33 18.94 19.28 54375 20091120 WU 19.21 19.25 18.71 18.83 93199 20091123 WU 18.95 19.21 18.91 18.98 53069 20091124 WU 19.05 19.1 18.9 18.92 47627 20091125 WU 18.91 18.99 18.86 18.91 50013 20091127 WU 18.42 18.73 18.3 18.5 26642 20091130 WU 18.55 18.72 18.32 18.45 59024 20091201 WU 18.58 18.72 18.45 18.49 82648 20091202 WU 18.47 18.76 18.28 18.4 68836 20091203 WU 18.42 18.55 17.81 17.84 81113 20091204 WU 18.07 18.34 17.99 18.14 67333 20091207 WU 18.22 18.42 18 18.24 44338 20091208 WU 18.15 18.33 17.97 18.05 42969 20091209 WU 18.15 18.28 18.03 18.19 36161 20091210 WU 18.4 19.08 18.4 19 88125 20091211 WU 19.11 19.24 18.93 19.07 51320 20091214 WU 19.26 19.36 19 19.21 33219 20091215 WU 19.16 19.16 18.9 18.97 49240 20091216 WU 19.11 19.32 19.06 19.23 47648 20091217 WU 19.06 19.25 19 19.03 45088 20091218 WU 19.24 19.36 18.91 19.13 59878 20091221 WU 19.25 19.43 19.14 19.24 44430 20091222 WU 19.22 19.47 19.19 19.39 35389 20091223 WU 19.37 19.56 19.35 19.44 24827 20091224 WU 19.51 19.51 19.19 19.25 15199 20091228 WU 19.28 19.31 19.03 19.1 28251 20091229 WU 19.22 19.35 18.99 19.07 31340 20091230 WU 19 19.125 18.905 19.02 28735 20091231 WU 19.02 19.14 18.82 18.85 24181 20100104 WU 19.1 19.24 19.045 19.09 42778 20100105 WU 19.15 19.15 18.77 19.01 39148 20100106 WU 18.89 19.05 18.87 19 42078 20100107 WU 18.92 19.73 18.85 19.61 82568 20100108 WU 19.6 19.81 19.46 19.8 56738 20100111 WU 19.96 19.99 19.74 19.97 53261 20100112 WU 19.87 19.91 19.41 19.85 50871 20100113 WU 19.92 20.26 19.89 20.13 57821 20100114 WU 20.08 20.08 19.74 19.88 32485 20100115 WU 19.94 19.94 19.49 19.53 47125 20100119 WU 19.5 19.86 19.4 19.86 55099 20100120 WU 19.71 19.71 19.35 19.5 50089 20100121 WU 19.57 19.75 19.31 19.43 66011 20100122 WU 19.4 19.47 18.66 18.8 81536 20100125 WU 19.11 19.11 18.5 18.63 46017 20100126 WU 18.46 18.625 18.24 18.31 63897 20100127 WU 18.25 18.45 18.19 18.35 59301 20100128 WU 18.46 18.51 18.15 18.25 56981 20100129 WU 18.44 18.84 18.32 18.54 67242 20100201 WU 18.66 18.7 18.395 18.58 61743 20100202 WU 18.59 18.88 18.52 18.85 56098 20100203 WU 17.07 18.21 16.7 17.17 508481 20100204 WU 16.8 16.89 16.22 16.54 342944 20100205 WU 16.43 16.54 15.85 16.5 167198 20100208 WU 16.53 16.55 16.14 16.16 147857 20100209 WU 16.35 16.51 15.93 16.14 194611 20100210 WU 16.14 16.6 16.01 16.44 157284 20100211 WU 16.3 16.41 16.1 16.16 157815 - ---- - -27.31 27.54 57561 20100628 FIS 27.51 27.75 27.26 27.4 18080 20100629 FIS 27.18 27.29 26.91 27.05 45236 20100630 FIS 27.01 27.35 26.78 26.82 34760 20100701 FIS 27.01 27.05 26.45 26.53 59679 20100702 FIS 26.51 26.77 26.35 26.41 25303 20100706 FIS 27.49 27.49 26.62 27.17 70148 20100707 FIS 27.07 27.6 27.07 27.55 58059 20100708 FIS 27.66 27.77 27.49 27.65 43722 20100709 FIS 27.71 27.755 27.59 27.7 37557 20100712 FIS 27.7 27.87 27.54 27.75 66646 20100713 FIS 27.87 27.94 27.66 27.77 77042 20100714 FIS 27.74 28.15 27.7 27.93 72281 20100715 FIS 27.83 28.06 27.72 27.97 38056 20100716 FIS 27.81 27.88 27.5 27.52 60314 20100719 FIS 27.62 27.73 27.45 27.63 32132 20100720 FIS 27.55 27.97 27.44 27.9 74450 20100721 FIS 28 28 27.64 27.71 54270 20100722 FIS 27.84 28.15 27.8 28.03 69859 20100723 FIS 28.05 28.24 27.79 28.1 45549 20100726 FIS 28.11 28.27 27.87 28.2 51373 20100727 FIS 28.24 28.51 28.16 28.36 76270 20100728 FIS 28.34 28.62 28.32 28.5 98298 20100729 FIS 28.54 28.775 28.475 28.65 97660 20100730 FIS 28.44 28.73 28.44 28.67 88637 20100802 FIS 28.85 28.91 28.71 28.72 186941 20100803 FIS 28.73 29 28.7 28.79 220803 20100804 FIS 28 28 27.26 27.5 303905 20100805 FIS 27.46 27.82 27.27 27.66 76403 20100806 FIS 27.61 27.74 27.47 27.7 62512 20100809 FIS 27.81 28.01 27.57 27.88 49211 20100810 FIS 27.69 27.84 27.1 27.1 91137 20100811 FIS 26.75 26.81 26.36 26.36 68435 20100812 FIS 26.06 26.535 25.81 26.37 90382 20100813 FIS 26.35 26.6 26.23 26.5 115726 20100816 FIS 26.39 26.64 26.25 26.34 111754 20100817 FIS 26.51 26.96 26.44 26.84 48766 20100819 FIS 26.81 26.81 26.25 26.43 30515 20100820 FIS 26.36 26.56 26.28 26.49 21570 20090821 FISV 48.33 49.17 47.17 49.09 12086 20090824 FISV 49.19 49.46 48.97 49.3 11608 20090825 FISV 49.67 49.75 49.199 49.5 14434 20090826 FISV 49.33 49.89 49.29 49.46 10072 20090827 FISV 49.58 49.69 48.62 49.62 7889 20090828 FISV 49.81 49.91 48.76 49.21 6745 20090831 FISV 48.96 49.23 48.08 48.25 12430 20090901 FISV 48.24 49.21 47.53 47.55 18694 20090902 FISV 47.29 47.54 47.09 47.28 15792 20090903 FISV 47.27 47.37 46.4 46.88 17755 20090904 FISV 46.98 48.04 46.74 47.82 12283 20090909 FISV 47.79 48.67 47.475 48.61 21670 20090910 FISV 48.26 48.52 47.97 48.52 8776 20090911 FISV 48.19 48.52 47.98 48 11252 20090914 FISV 47.72 48.21 47.47 48.16 13676 20090915 FISV 48.13 48.83 47.89 48.69 11251 20090916 FISV 48.66 49.36 48.13 49.2 13268 20090917 FISV 49.23 49.72 49.07 49.39 9338 20090918 FISV 49.68 49.8 49.17 49.43 15687 20090921 FISV 49.38 49.87 49.01 49.65 10533 20090922 FISV 49.68 49.84 49.04 49.32 9436 20090923 FISV 49.07 49.71 48.99 49.06 18112 20090924 FISV 49.16 49.28 48.3 48.43 14257 20090925 FISV 48.63 49.2 48.21 48.46 15047 20090928 FISV 48.48 49.21 48.4 49 14161 20090929 FISV 48.68 49.16 47.92 47.96 15025 20090930 FISV 48.1 48.57 47.1 48.2 22132 20091001 FISV 47.82 48.12 46.71 47.02 24970 20091002 FISV 46.84 47.31 46.66 46.84 11835 20091005 FISV 46.8 47.4698 46.66 47.39 10702 20091006 FISV 46.95 48.11 46.9 47.93 10180 20091007 FISV 47.53 48.34 47.49 48.23 12843 20091008 FISV 48.57 48.98 48.32 48.48 11100 20091009 FISV 48.23 49.05 48.07 49.04 10327 20091012 FISV 48.58 49.25 48.52 48.87 7168 20091013 FISV 48.73 48.74 48.27 48.61 10431 20091014 FISV 48.71 49.13 48.62 49.1 9807 20091015 FISV 48.92 49.28 48.74 49.11 7466 20091016 FISV 48.82 49.2701 47.93 48.35 18715 20091019 FISV 48.45 49.46 48.36 49.43 18510 20091020 FISV 49.31 49.39 48.79 49.18 13258 20091021 FISV 49.26 50 49.09 49.3 15282 20091022 FISV 49.35 49.59 48.49 49.4 12851 20091023 FISV 48.8 49.68 48.55 48.61 10554 20091026 FISV 48.79 49.65 48.21 48.79 16139 20091027 FISV 49.38 49.56 48.66 49.08 15942 20091028 FISV 48.03 48.2 46 46.14 33535 20091105 FISV 46.69 47.78 46.51 47.7 12147 20091106 FISV 47.16 47.78 47.06 47.58 8716 20091109 FISV 47.72 48.64 47.61 48.64 10179 20091110 FISV 48.34 48.7 48.18 48.48 8856 20091111 FISV 48.38 48.88 48.09 48.51 7604 20091113 FISV 47.93 48.01 47.24 47.83 19545 20091116 FISV 47.74 48.69 47.72 48.56 8609 20091117 FISV 48.45 48.84 48.19 - ---- - -9785 20100621 AYE 22.46 22.49 21.7392 21.94 23755 20100622 AYE 21.98 21.98 21.15 21.2 21496 20100623 AYE 21.26 21.39 20.93 21.04 8429 20100624 AYE 20.98 21.44 20.86 21.05 15512 20100625 AYE 21.05 21.26 20.77 21.03 39006 20100628 AYE 21.04 21.4325 20.92 21.29 13473 20100629 AYE 21.07 21.13 20.73 20.79 27205 20100630 AYE 20.72 21.13 20.59 20.68 18408 20100701 AYE 20.69 20.69 20.2 20.32 19731 20100702 AYE 20.34 20.46 20.01 20.14 18212 20100706 AYE 20.46 20.64 20.23 20.49 21104 20100707 AYE 20.5 21.34 20.38 21.32 21829 20100708 AYE 21.44 21.7 21.3 21.7 15626 20100709 AYE 21.69 22.11 21.53 22.07 12394 20100712 AYE 21.97 22.2 21.82 22.16 7776 20100713 AYE 22.32 22.59 22.1 22.23 16154 20100714 AYE 22.21 22.5 22 22.48 11512 20100715 AYE 22.42 22.535 22.19 22.43 15964 20100716 AYE 22.27 22.43 22.14 22.3 18372 20100719 AYE 22.37 22.83 22.21 22.76 15312 20100720 AYE 22.56 23.06 22.47 23.06 14858 20100721 AYE 23.13 23.26 22.78 22.9 16335 20100722 AYE 23.02 23.5 23.02 23.34 14372 20100723 AYE 23.35 23.3799 22.84 23.08 18774 20100726 AYE 23.03 23.25 22.93 23.08 14091 20100727 AYE 23.26 23.74 23.1 23.72 29506 20100728 AYE 23.6 23.815 23.4993 23.61 31366 20100729 AYE 23.63 23.74 22.84 23.09 34744 20100730 AYE 22.84 22.96 22.61 22.8 28697 20100802 AYE 23.06 23.33 22.96 23.31 20201 20100803 AYE 23.24 23.71 23.22 23.48 37032 20100804 AYE 23.39 23.45 22.93 23.37 17702 20100805 AYE 23.05 23.415 22.96 23.25 19908 20100806 AYE 23.12 23.25 22.82 23.07 30395 20100809 AYE 23.15 23.24 22.92 23.06 20333 20100810 AYE 22.95 23.19 22.67 23.02 43530 20100811 AYE 22.76 22.76 22.21 22.3 26695 20100812 AYE 22 22.2 21.95 22.07 17857 20100813 AYE 21.95 22.5 21.95 22.27 14293 20100816 AYE 22.24 22.49 22.04 22.49 17505 20100817 AYE 22.58 23 22.49 22.81 16627 20100819 AYE 22.65 22.65 22.19 22.29 19338 20100820 AYE 22.19 22.26 21.98 22.04 15804 20090821 AZO 151.8 153.28 151.03 153.25 5204 20090824 AZO 152.96 153.37 150.66 150.8 5927 20090825 AZO 151.27 151.81 149.69 149.98 8689 20090826 AZO 149.76 151.95 149.42 150.22 6983 20090827 AZO 149.7 150.23 147.81 149.07 8632 20090828 AZO 149.6 150.57 147 148.45 11217 20090831 AZO 146.61 147.56 145.76 147.25 11537 20090901 AZO 146.34 147.95 144.24 144.94 10060 20090902 AZO 145.14 146.17 144.2 145.25 5781 20090903 AZO 145.38 148.98 144.77 148.81 8172 20090904 AZO 148.95 148.99 147.25 148.18 4621 20090909 AZO 149.84 150.3 148.04 149.32 6081 20090910 AZO 149.31 150.23 147.88 149.4 5725 20090911 AZO 148.75 149.16 145.87 146.45 9961 20090914 AZO 145.34 147.44 144.82 147.2 5787 20090915 AZO 147.36 147.76 145.36 147.28 8256 20090916 AZO 147.59 148.76 146.42 147.41 6221 20090917 AZO 147.56 148.97 146.73 147.37 6167 20090918 AZO 146.91 152.55 146.88 152.09 15510 20090921 AZO 151.81 154.31 150 153.55 9015 20090922 AZO 154.69 154.69 151.74 152.92 8698 20090923 AZO 148.61 148.94 141.44 141.5 39022 20090924 AZO 142.72 144.4 142.05 142.5 16205 20090925 AZO 142.18 144.501 142 143.97 11592 20090928 AZO 143.98 145.44 142.41 142.77 8626 20090929 AZO 143.26 146.76 143.26 145.98 15280 20090930 AZO 145.17 147 144.45 146.22 9944 20091001 AZO 145.77 147.06 144.13 145.62 13803 20091002 AZO 144.21 147.32 143.82 146.05 11320 20091005 AZO 145.7 147.12 144.57 145.14 11861 20091006 AZO 146.24 147.66 145.33 147.08 9279 20091007 AZO 146.59 147.4 144.7 147.21 7777 20091008 AZO 147.5 148.78 146.86 147.12 6061 20091009 AZO 147.11 147.74 145.05 145.92 7460 20091012 AZO 146.12 146.83 144.4 144.87 7464 20091013 AZO 144.82 145.92 143.86 144.7 6634 20091014 AZO 145 145.89 143.4 143.95 11636 20091015 AZO 143.41 145.36 143.21 144.67 9082 20091016 AZO 143.81 145.91 143.81 144.52 7396 20091019 AZO 143.84 145.34 142.25 144 13629 20091020 AZO 143.9 143.9 140.4 140.94 13778 20091021 AZO 141.07 142 137.98 137.99 11664 20091022 AZO 137.47 139.45 137.19 139.1 9294 20091023 AZO 139.59 139.59 137.28 137.62 8408 20091026 AZO 137.51 139.15 137.03 137.46 5570 20091027 AZO 137.46 138.79 135.68 137.17 9155 20091028 AZO 136.55 138.97 136.34 136.42 10667 20091105 AZO 140.16 140.835 - ---- - -SE 18.79 18.88 18.59 18.82 34654 20090901 SE 18.76 18.8605 18.33 18.36 35843 20090902 SE 18.32 18.42 18.2 18.28 22223 20090903 SE 18.46 18.47 18.05 18.23 31103 20090904 SE 18.23 18.47 18.16 18.39 26806 20090909 SE 18.77 19.06 18.69 18.82 36369 20090910 SE 18.9 19.16 18.73 19.08 27488 20090911 SE 19.16 19.28 19.03 19.09 27901 20090914 SE 19.18 19.26 18.89 19.18 31569 20090915 SE 19.18 19.45 19 19.44 39335 20090916 SE 19.41 19.72 19.35 19.71 35461 20090917 SE 19.65 19.73 19.36 19.39 39269 20090918 SE 19.53 19.59 19.3 19.5 44586 20090921 SE 19.17 19.5 19.16 19.43 24701 20090922 SE 19.72 19.72 19.42 19.67 30795 20090923 SE 19.67 19.71 19.29 19.29 31433 20090924 SE 19.32 19.42 18.96 19.05 34045 20090925 SE 18.96 19.31 18.89 19.07 31664 20090928 SE 19.13 19.34 19.03 19.19 24264 20090929 SE 19.21 19.28 19.04 19.14 25823 20090930 SE 19.24 19.26 18.75 18.94 52220 20091001 SE 18.93 19.02 18.58 18.61 45098 20091002 SE 18.36 18.57 18.26 18.42 43315 20091005 SE 18.47 18.92 18.36 18.9 32573 20091006 SE 19.09 19.18 18.95 19.15 43570 20091007 SE 19.15 19.28 18.95 19.21 25657 20091008 SE 19.31 19.65 19.16 19.5 36007 20091009 SE 20.41 20.45 19.74 19.76 58089 20091012 SE 20 20.14 19.82 19.93 28894 20091013 SE 20.01 20.03 19.65 19.76 30201 20091014 SE 19.98 20.1 19.82 20.1 35321 20091015 SE 19.97 20.53 19.91 20.53 37705 20091016 SE 20.35 20.39 20.05 20.33 37418 20091019 SE 20.28 20.46 20.16 20.42 26675 20091020 SE 20.55 20.55 20.075 20.3 33626 20091021 SE 20.21 20.42 20.03 20.2 46745 20091022 SE 20.18 20.4 20.05 20.35 36187 20091023 SE 20.36 20.48 19.85 20 43450 20091026 SE 20 20.45 19.69 19.69 43123 20091027 SE 19.21 19.58 18.6 19.49 69625 20091028 SE 19.41 19.41 18.98 19 47917 20091105 SE 19.71 19.74 19.15 19.34 46425 20091106 SE 19.13 19.41 19.09 19.34 25403 20091109 SE 19.57 19.7 19.34 19.69 39275 20091110 SE 19.43 19.48 19.21 19.34 36419 20091111 SE 19.44 19.55 19.15 19.25 29241 20091112 SE 19.17 19.33 18.93 18.97 32117 20091113 SE 18.99 19.25 18.91 19.17 30965 20091116 SE 19.2 19.5 19.02 19.38 32231 20091117 SE 19.37 19.45 19.14 19.37 27989 20091118 SE 19.4 19.45 19.14 19.25 18795 20091119 SE 19.2 19.2 18.83 19.01 33444 20091120 SE 19.06 19.18 18.9 19.1 28241 20091123 SE 19.32 19.67 19.32 19.39 36473 20091124 SE 19.36 19.44 19.15 19.43 24613 20091125 SE 19.51 19.67 19.42 19.66 17920 20091127 SE 19.24 19.43 19.1 19.31 17792 20091130 SE 19.38 19.55 19.19 19.41 25361 20091201 SE 19.41 19.63 19.41 19.57 24388 20091202 SE 19.62 19.68 19.4301 19.51 25748 20091203 SE 19.54 19.74 19.41 19.42 26423 20091204 SE 19.71 19.88 19.48 19.62 38138 20091207 SE 19.62 19.82 19.59 19.62 23294 20091208 SE 19.5 19.6799 19.34 19.54 25785 20091209 SE 19.56 19.73 19.5 19.68 29761 20091210 SE 19.72 20.15 19.72 20.11 29976 20091211 SE 20.21 20.25 20.02 20.19 21132 20091214 SE 20.43 20.73 20.4 20.57 28916 20091215 SE 20.64 20.665 20.38 20.4 41804 20091216 SE 20.58 20.72 20.28 20.51 29449 20091217 SE 20.39 20.52 20.305 20.35 20576 20091218 SE 20.4 20.57 20.19 20.23 43385 20091221 SE 20.25 20.53 20.25 20.42 22582 20091222 SE 20.5 20.53 20.29 20.44 20042 20091223 SE 20.41 20.54 20.41 20.51 15842 20091224 SE 20.47 20.67 20.47 20.58 9047 20091228 SE 20.58 20.66 20.44 20.54 13850 20091229 SE 20.56 20.69 20.51 20.56 16590 20091230 SE 20.47 20.78 20.47 20.65 19417 20091231 SE 20.63 20.75 20.51 20.51 12932 20100104 SE 20.66 20.81 20.61 20.81 31012 20100105 SE 20.85 20.89 20.3 20.66 46405 20100106 SE 20.6 20.81 20.6 20.7 36176 20100107 SE 20.64 20.81 20.53 20.81 29716 20100108 SE 20.87 21 20.75 20.99 28269 20100111 SE 21.08 21.23 20.98 21.06 39123 20100112 SE 20.96 21.39 20.85 21.13 52826 20100113 SE 21.49 21.76 21.42 21.7 52865 20100114 SE 22 22.28 21.79 22.18 46966 20100115 SE 22.37 22.37 21.85 22.12 48229 20100119 SE 22.19 23.06 22.16 23.03 59719 20100120 SE 22.85 22.94 22.675 22.74 66809 20100121 SE 22.77 23.06 22.4 22.61 71435 20100122 SE 22.48 22.5 21.94 21.99 70537 20100125 SE 22.1 22.45 22.1 22.29 43780 20100126 SE 22.1 22.52 22.1 22.26 41357 20100127 SE 22.26 22.37 - ---- - -a,b,c -1,2,qq -1,2,qq -1,2,qq -1,2,qq -4,5 - -1,2,qq -1,2,qq -1,2,qq -1,2,qq -1,2,qq -1 - - -1,2,qq - -1,2,qq -1,2,qq -1,2,qq -1 - -1 -1 -1,2,qq -1,2,qq -1,2,qq -1,2,er - ---- - -21.19 20.82 21.02 23162 20100211 AYE 22.78 23.77 22.78 23.55 281235 20100212 AYE 23.49 23.56 22.54 22.72 135049 20100216 AYE 23.05 23.22 22.6 22.84 54802 20100217 AYE 22.87 22.9965 22.49 22.59 36250 20100218 AYE 22.63 22.77 22.48 22.7 28832 20100219 AYE 22.61 23.445 22.53 23.35 26612 20100222 AYE 23.37 23.59 23.26 23.37 41076 20100223 AYE 23.34 23.36 22.945 23 28138 20100224 AYE 23.04 23.05 22.775 23.01 22778 20100225 AYE 22.61 23 22.55 22.95 34089 20100226 AYE 22.93 22.99 22.6 22.65 32401 20100301 AYE 22.74 23.07 22.74 22.94 23944 20100302 AYE 23.03 23.2 22.99 23.08 24313 20100303 AYE 23.15 23.16 22.89 22.97 34270 20100304 AYE 22.9 22.97 22.67 22.75 28709 20100305 AYE 22.83 23.29 22.82 23.23 25602 20100308 AYE 23.25 23.32 23.16 23.25 12995 20100309 AYE 23.18 23.3099 23.08 23.19 15198 20100310 AYE 23.13 23.49 23.13 23.37 22777 20100311 AYE 23.39 23.48 23.3099 23.41 14596 20100312 AYE 23.41 23.535 23.2 23.28 16774 20100315 AYE 23.23 23.44 23.2 23.38 27064 20100316 AYE 23.48 23.59 23.29 23.58 14947 20100317 AYE 23.6 23.745 23.5 23.67 19509 20100318 AYE 23.61 23.7 23.26 23.36 12006 20100319 AYE 23.46 23.6 23.242 23.44 13632 20100322 AYE 23.3 23.65 23.26 23.49 20697 20100323 AYE 23.49 23.99 23.49 23.78 21963 20100324 AYE 23.83 23.9 23.69 23.76 27376 20100325 AYE 23.75 23.88 23.05 23.1 24425 20100326 AYE 23.07 23.22 22.82 22.89 26987 20100329 AYE 22.91 23 22.66 22.92 29211 20100330 AYE 22.89 23 22.81 22.89 24598 20100331 AYE 22.83 23.09 22.74 23 32733 20100401 AYE 23.09 23.24 23 23.05 31372 20100405 AYE 23.07 23.1525 23 23.07 26255 20100406 AYE 22.99 23.22 22.97 23.22 36985 20100407 AYE 23.09 23.25 22.9975 23.09 21981 20100408 AYE 23.04 23.12 22.97 23.02 16414 20100409 AYE 23 23.25 22.97 23.25 21664 20100412 AYE 23.31 23.47 23.2 23.23 20422 20100413 AYE 23.25 23.35 22.98 23.08 29771 20100414 AYE 23.05 23.14 22.8 22.83 35114 20100415 AYE 22.84 22.84 22.54 22.71 35632 20100416 AYE 22.7 22.7 22.16 22.27 65517 20100419 AYE 22.2 22.34 22 22.05 51390 20100420 AYE 22.19 22.19 21.98 22.06 71382 20100421 AYE 22.07 22.19 21.95 21.98 30786 20100422 AYE 21.91 21.91 21.47 21.67 32906 20100423 AYE 21.71 21.73 21.51 21.57 49929 20100426 AYE 21.6 21.62 21.18 21.41 42379 20100427 AYE 21.32 21.74 21.19 21.2 25506 20100428 AYE 21.29 21.825 21.2 21.53 35948 20100429 AYE 21.61 21.95 21.42 21.49 36731 20100430 AYE 21.56 21.84 21.51 21.78 33993 20100503 AYE 21.86 22.04 21.53 21.9 29543 20100504 AYE 21.81 22 21.26 21.38 34547 20100505 AYE 21.23 21.29 20.72 20.75 47373 20100506 AYE 20.61 20.91 19.06 20.33 61439 20100507 AYE 20.35 20.49 19.86 19.95 69081 20100510 AYE 20.5 20.84 20.31 20.6 38721 20100511 AYE 20.39 20.75 20.37 20.47 25444 20100512 AYE 20.46 21.27 20.44 21.2 35555 20100513 AYE 21.19 22.05 21.02 21.58 44918 20100514 AYE 21.48 21.94 21.39 21.54 41641 20100517 AYE 21.51 21.51 20.77 21.04 32253 20100518 AYE 21.09 21.16 20.47 20.52 51254 20100519 AYE 20.5 20.62 20.21 20.48 27328 20100520 AYE 20.17 20.2 19.66 19.69 34516 20100521 AYE 19.5 19.92 19.3 19.9 26858 20100524 AYE 19.81 20.05 19.615 19.76 17349 20100525 AYE 19.39 19.52 18.965 19.49 26988 20100526 AYE 19.5 19.93 19.41 19.73 27189 20100527 AYE 19.98 20.27 19.81 20.24 20238 20100528 AYE 20.29 20.68 20.24 20.46 23409 20100601 AYE 20.3 20.3 19.63 19.63 20781 20100602 AYE 19.67 20.21 19.64 20.21 21671 20100603 AYE 20.15 20.72 20.06 20.62 29007 20100604 AYE 20.28 20.82 20.27 20.33 29893 20100607 AYE 20.28 21.06 20.28 20.76 29210 20100608 AYE 20.74 21.02 20.6 20.85 31774 20100609 AYE 20.93 20.97 20.59 20.65 19504 20100610 AYE 20.92 21.34 20.92 21.33 20394 20100611 AYE 21.15 21.35 21.036 21.34 8052 20100614 AYE 21.53 21.65 21.28 21.53 11503 20100615 AYE 21.65 21.87 21.62 21.84 11867 20100616 AYE 21.7 22.06 21.69 21.91 9299 20100617 AYE 21.95 22.31 21.805 22.26 15604 20100618 AYE 22.31 22.31 22.06 22.28 9785 20100621 AYE 22.46 22.49 21.7392 21.94 23755 20100622 AYE 21.98 21.98 21.15 21.2 21496 20100623 AYE 21.26 21.39 20.93 21.04 8429 20100624 AYE 20.98 21.44 20.86 21.05 15512 20100625 AYE 21.05 - ---- - -SII 27.52 27.55 26.5 26.8 80931 20091221 SII 27.19 27.47 27.01 27.11 38331 20091222 SII 27.12 27.32 26.965 27.24 38372 20091223 SII 27.53 27.66 27.23 27.45 29770 20091224 SII 27.61 27.64 27.21 27.25 12107 20091228 SII 27.51 27.75 27.21 27.31 17042 20091229 SII 27.56 27.56 27 27.2 22887 20091230 SII 27.08 27.35 26.98 27.26 18287 20091231 SII 27.43 27.51 27.03 27.17 15276 20100104 SII 27.67 28.05 27.62 27.99 42084 20100105 SII 28.16 28.97 28.07 28.83 58180 20100106 SII 28.87 30.09 28.67 30.06 70546 20100107 SII 29.73 30.34 29.7 30.25 34757 20100108 SII 30.1 31.2 29.91 31.12 37389 20100111 SII 31.51 31.57 30.4312 31.03 46454 20100112 SII 30.2 30.77 29.82 30.03 34684 20100113 SII 30.05 30.15 29.22 30.04 36123 20100114 SII 30.14 30.71 29.9 30.57 37486 20100115 SII 30.44 30.84 29.79 30.11 47121 20100119 SII 30.04 30.31 29.65 30.3 33438 20100120 SII 29.88 30.79 29.815 30.1 69635 20100121 SII 30.09 31.46 30.04 31.16 138175 20100122 SII 30.68 31.29 29.86 29.94 86628 20100125 SII 30.13 31 30.05 30.51 52942 20100126 SII 30.14 31.31 29.95 30.56 63769 20100127 SII 30.42 31.9 29.8899 30.97 82388 20100128 SII 31.35 31.42 30.37 30.81 66736 20100129 SII 31.17 31.98 30 30.32 70662 20100201 SII 30.72 31.65 30.43 31.58 39274 20100202 SII 31.73 32.1 31.49 31.7 46400 20100203 SII 31.7 32.31 31.21 31.55 31906 20100204 SII 31.08 31.08 30.23 30.35 48903 20100205 SII 30.4 30.75 29.14 30.28 56928 20100208 SII 30.4 30.95 29.9 30.21 38624 20100209 SII 30.72 31.71 30.49 31.05 57999 20100210 SII 31.09 31.79 30.51 31.79 48912 20100211 SII 31.68 32.32 31.16 32.18 45333 20100212 SII 31.58 32.04 31.23 31.97 37554 20100216 SII 32.47 33.02 32.34 32.86 33296 20100217 SII 33.03 33.33 32.78 33.05 30096 20100218 SII 32.95 33.49 32.61 33.35 41535 20100219 SII 37.97 38.16 36.95 37.7 428065 20100222 SII 40.03 41.305 39.84 41.03 1219686 20100223 SII 41.03 41.21 40.22 40.76 418006 20100224 SII 40.89 41.14 40.4 40.85 253758 20100225 SII 40.21 40.84 39.7175 40.83 149670 20100226 SII 40.99 41.2 40.56 40.99 153903 20100301 SII 41.48 41.55 40.9 41.22 150998 20100302 SII 41.38 42.25 41.09 42.21 134324 20100303 SII 42.54 43 42.35 42.49 95638 20100304 SII 42.48 42.85 41.88 42.32 113936 20100305 SII 42.71 43.01 42.54 42.97 103075 20100308 SII 42.86 43.61 42.86 43.49 81072 20100309 SII 43.23 43.52 42.9 43.28 55624 20100310 SII 43.04 43.54 42.6 43.39 69833 20100311 SII 43.18 43.3 42.77 43.13 41569 20100312 SII 43.46 43.71 43.11 43.59 62126 20100315 SII 43.26 43.7 42.775 43.5 59596 20100316 SII 43.8 44.48 43.37 44.34 60357 20100317 SII 44.56 45.32 44.34 45.13 67270 20100318 SII 45 45.19 43.77 44.05 77458 20100319 SII 44.18 44.41 42.98 43.31 115298 20100322 SII 42.39 43.365 41.79 42.82 60385 20100323 SII 42.85 43.2 42.35 42.51 61552 20100324 SII 42.1 42.75 41.91 42.07 39172 20100325 SII 42.44 42.7 40.91 40.93 49321 20100326 SII 41.19 41.87 41.19 41.62 39405 20100329 SII 41.95 42.77 41.8 42.58 72144 20100330 SII 42.6 43.06 42.34 42.49 40373 20100331 SII 42.83 42.85 42.45 42.82 86548 20100401 SII 43.33 43.79 43.1775 43.59 57376 20100405 SII 43.97 44.71 43.7 44.43 47585 20100406 SII 44.37 45.28 44.36 45.11 52076 20100407 SII 44.99 45.08 44.3299 44.58 43982 20100408 SII 44.19 45.11 43.91 44.98 33176 20100409 SII 45.29 45.5 44.685 44.85 52604 20100412 SII 44.81 45.16 44.64 44.72 34271 20100413 SII 44.91 44.91 43.61 44.23 44747 20100414 SII 44.6 45.54 44.4107 45.4 44458 20100415 SII 45.25 45.64 44.94 45.51 23040 20100416 SII 44.93 45.38 43.74 44.37 55187 20100419 SII 43.96 44.47 43.47 43.98 38198 20100420 SII 44.68 45.89 44.58 45.79 47210 20100421 SII 45.77 46.19 45.27 45.83 42409 20100422 SII 45.15 46.08 44.99 45.91 45765 20100423 SII 47.32 49.44 46.87 49.15 73007 20100426 SII 49.2 49.37 48.73 48.99 49488 20100427 SII 48.72 48.96 47.05 47.27 59383 20100428 SII 47.56 47.9 46.51 47.79 54313 20100429 SII 48.55 49.66 48.21 48.83 201169 20100430 SII 49.03 49.2 46.6 47.76 170794 20100503 SII 47.76 48.29 46.94 47.76 115480 20100504 SII 46.71 47.47 45.9 46.15 71278 20100505 SII 45.12 45.92 44.39 - ---- - -14.76 14.08 14.23 40648 20100728 GCI 14.185 14.37 13.77 13.9 28940 20100729 GCI 14.04 14.18 13.1 13.25 63195 20100730 GCI 13.02 13.275 12.88 13.18 39478 20100802 GCI 13.51 13.86 13.31 13.69 42775 20100803 GCI 13.58 13.58 13.21 13.21 27861 20100804 GCI 13.32 13.46 13.16 13.41 37666 20100805 GCI 13.24 13.36 13.06 13.31 33977 20100806 GCI 13.1 13.39 13.01 13.15 32064 20100809 GCI 13.26 13.49 13.19 13.49 21682 20100810 GCI 13.32 13.42 13.07 13.29 28788 20100811 GCI 13 13.06 12.69 12.88 65489 20100812 GCI 12.58 12.87 12.5 12.78 44572 20100813 GCI 12.65 12.97 12.59 12.66 42588 20100816 GCI 12.51 12.77 12.34 12.6 29251 20100817 GCI 12.71 12.88 12.42 12.73 38361 20100819 GCI 12.71 12.85 12.5 12.54 65974 20100820 GCI 12.42 12.59 12.13 12.32 34491 20090821 GD 56.13 58.68 56.1 58.49 42043 20090824 GD 58.78 58.98 58.33 58.74 17813 20090825 GD 59.01 59.72 58.63 58.71 19038 20090826 GD 58.74 58.86 57.87 58.73 22353 20090827 GD 59.07 60 58.76 59.95 24808 20090828 GD 60.17 60.17 59.34 59.77 22941 20090831 GD 59.52 59.56 58.68 59.19 20779 20090901 GD 59.15 59.73 58.11 58.6 19186 20090902 GD 58.48 58.81 57.7105 58.13 18388 20090903 GD 58.4 58.83 57.36 58.8 20275 20090904 GD 58.83 60.71 58.83 60.48 26804 20090909 GD 63.07 63.52 61.68 62.19 30661 20090910 GD 62.3 62.73 61.42 62.53 22236 20090911 GD 62.79 63.43 62.4 63.34 20660 20090914 GD 63.2 63.2 62.43 63.1 20281 20090915 GD 63.2 63.26 62.75 63.13 15364 20090916 GD 63.25 63.31 62.19 63.29 21091 20090917 GD 63.03 64.86 62.84 64.43 32268 20090918 GD 64.58 64.845 63.88 64.61 21451 20090921 GD 64.11 64.53 63.46 63.64 19365 20090922 GD 63.87 64.24 63.49 63.86 24620 20090923 GD 64.1 64.11 63.1 63.23 19514 20090924 GD 63.41 63.41 61.93 62.28 20451 20090925 GD 62.02 63.11 61.81 62.99 32697 20090928 GD 64.11 64.83 63.64 64.54 23101 20090929 GD 64.51 65.16 64.16 64.47 20969 20090930 GD 65.32 65.32 63.46 64.6 33013 20091001 GD 64.4 64.74 63.1 63.15 41368 20091002 GD 62.78 63.3 62.63 63.08 29353 20091005 GD 64.62 65 63.76 64.77 30031 20091006 GD 65.12 66.05 65 65.92 26586 20091007 GD 65.63 65.86 64.85 65.51 25133 20091008 GD 65.98 66.08 65 65.28 25456 20091009 GD 65.25 66.16 65.01 66.16 13978 20091012 GD 66.27 66.47 65.26 65.61 10776 20091013 GD 65.37 65.9 65.11 65.59 14878 20091014 GD 66.29 67.04 65.67 66.85 17115 20091015 GD 66.76 67.44 66.54 67.32 18766 20091016 GD 67.02 67.9 66.53 67.75 24837 20091019 GD 67.9 68.84 67.67 68.7 20839 20091020 GD 68.32 68.37 67.04 67.63 25891 20091021 GD 67.68 68.4 66.62 66.7 17126 20091022 GD 66.7 67.819 66.65 67.75 18528 20091023 GD 67.99 67.99 66.21 66.6 16985 20091026 GD 66.66 67.72 65.82 65.96 24505 20091027 GD 66.01 67.08 65.69 65.78 27139 20091028 GD 64.98 65.93 64.22 64.3 37228 20091105 GD 64.06 65.92 64.06 65.39 21145 20091106 GD 65.25 65.82 64.77 65.58 16777 20091109 GD 65.9 67.41 65.82 67.31 17022 20091110 GD 67.04 67.59 66.38 66.56 18686 20091111 GD 66.9 67.52 66.8 66.97 16372 20091112 GD 66.83 67.72 66.54 66.72 12024 20091113 GD 66.88 68 66.58 67.68 12571 20091116 GD 67.86 68.74 67.64 68.21 20881 20091117 GD 68.26 68.26 67.59 67.94 10401 20091118 GD 67.92 68.06 67.1 67.34 14812 20091119 GD 67.15 67.15 65.84 66.38 16676 20091120 GD 66.23 66.7 65.96 66.47 18601 20091123 GD 66.87 67.7 66.77 67.52 11712 20091124 GD 67.42 67.52 66.75 67.32 13148 20091125 GD 67.45 68.3 66.8764 68.13 15845 20091127 GD 66.95 67.54 66.19 67.08 10646 20091130 GD 67.25 67.25 65.46 65.9 28469 20091201 GD 66.49 67.46 66.23 67.14 18502 20091202 GD 67.29 67.73 66.84 67.09 18931 20091203 GD 67.11 67.73 66.68 66.78 13996 20091204 GD 67.16 68.43 66.76 67.54 17174 20091207 GD 67.55 68.21 67.49 67.88 11078 20091208 GD 67.61 68.15 66.83 67.82 19593 20091209 GD 67.96 67.96 66.94 67.9 18602 20091210 GD 68.02 68.68 67.86 68.01 10704 20091211 GD 68.05 69.17 68.01 69.01 15083 20091214 GD 69.32 70.84 69.21 70.66 25695 20091215 GD 70.4 70.58 69.48 69.67 21585 20091216 GD 69.82 70.04 68.85 69.45 20950 20091217 GD 69.05 69.32 68.4 68.51 12420 20091218 GD 68.78 68.93 67.7502 68.24 23280 20091221 GD 68.51 - ---- - -4.71 4.74 125639 20100622 THC 4.74 4.83 4.68 4.7 85307 20100623 THC 4.71 4.84 4.6 4.77 119881 20100624 THC 4.76 4.8 4.6 4.62 122849 20100625 THC 4.64 4.72 4.58 4.71 87402 20100628 THC 4.72 4.82 4.65 4.66 123913 20100629 THC 4.59 4.59 4.39 4.43 165226 20100630 THC 4.41 4.54 4.34 4.34 145011 20100701 THC 4.47 4.47 4.05 4.31 207485 20100702 THC 4.31 4.38 4.06 4.15 110705 20100706 THC 4.27 4.45 4.24 4.32 158207 20100707 THC 4.31 4.37 4.21 4.33 82762 20100708 THC 4.37 4.5 4.31 4.48 101324 20100709 THC 4.48 4.6 4.41 4.57 53822 20100712 THC 4.58 4.62 4.455 4.58 88073 20100713 THC 4.61 4.66 4.51 4.56 63160 20100714 THC 4.54 4.65 4.46 4.58 64691 20100715 THC 4.57 4.78 4.52 4.75 81097 20100716 THC 4.71 4.72 4.47 4.49 74512 20100719 THC 4.51 4.59 4.47 4.55 58234 20100720 THC 4.48 4.61 4.43 4.6 54439 20100721 THC 4.63 4.63 4.28 4.3 85926 20100722 THC 4.35 4.42 4.26 4.28 89950 20100723 THC 4.29 4.46 4.28 4.41 55045 20100726 THC 4.44 4.6 4.39 4.56 72692 20100727 THC 4.63 4.65 4.43 4.47 65097 20100728 THC 4.46 4.5 4.34 4.38 83538 20100729 THC 4.37 4.6 4.37 4.41 124026 20100730 THC 4.36 4.65 4.34 4.6 93921 20100802 THC 4.64 4.78 4.57 4.59 120000 20100803 THC 4.6 4.6 4.25 4.39 240014 20100804 THC 4.4 4.67 4.4 4.62 117328 20100805 THC 4.59 4.64 4.44 4.44 92097 20100806 THC 4.42 4.47 4.36 4.42 58086 20100809 THC 4.44 4.54 4.37 4.52 32093 20100810 THC 4.45 4.58 4.42 4.5 60071 20100811 THC 4.41 4.46 4.28 4.3 80620 20100812 THC 4.27 4.34 4.18 4.2 63864 20100813 THC 4.21 4.26 4.17 4.17 43121 20100816 THC 4.14 4.23 4.1 4.13 47486 20100817 THC 4.15 4.31 4.15 4.24 66570 20100819 THC 4.23 4.28 4.15 4.17 56755 20100820 THC 4.15 4.26 4.12 4.23 46182 20090821 TIE 8.08 8.3 8.06 8.22 18571 20090824 TIE 8.31 8.45 8.12 8.19 17570 20090825 TIE 8.24 8.25 7.92 7.96 20993 20090826 TIE 8.01 8.13 7.84 8.06 22310 20090827 TIE 8.12 8.69 7.97 8.62 58091 20090828 TIE 8.7 8.82 8.32 8.53 45795 20090831 TIE 8.45 8.52 8.17 8.22 28326 20090901 TIE 8.25 8.34 7.87 7.88 35828 20090902 TIE 7.88 8.1001 7.67 7.97 25991 20090903 TIE 8.035 8.22 8 8.2 19421 20090904 TIE 8.25 8.35 8.1 8.35 22800 20090909 TIE 9.03 9.49 8.8299 9.41 65660 20090910 TIE 9.69 9.97 9.35 9.89 69913 20090911 TIE 10.01 10.29 9.6216 9.86 52976 20090914 TIE 9.7 9.99 9.62 9.95 24213 20090915 TIE 9.99 10.28 9.95 10.28 31627 20090916 TIE 10.46 10.63 10.34 10.49 35573 20090917 TIE 10.31 10.53 10.07 10.16 32131 20090918 TIE 10.24 10.26 9.97 10.12 23186 20090921 TIE 9.83 9.99 9.61 9.91 22199 20090922 TIE 10.16 10.41 10.09 10.24 25595 20090923 TIE 10.26 10.53 10.12 10.16 22358 20090924 TIE 10.15 10.234 9.6 9.72 34903 20090925 TIE 9.45 9.62 9.28 9.41 33316 20090928 TIE 9.42 9.72 9.34 9.67 21195 20090929 TIE 9.82 9.93 9.6 9.67 25873 20090930 TIE 9.8 9.83 9.46 9.59 26772 20091001 TIE 9.6 9.6 9.08 9.08 32456 20091002 TIE 8.95 9.3 8.89 9.03 28379 20091005 TIE 9.09 9.49 9.01 9.41 22203 20091006 TIE 9.64 9.89 9.5 9.73 25513 20091007 TIE 9.68 9.83 9.55 9.8 19751 20091008 TIE 10 10.35 9.9 10.22 34832 20091009 TIE 10.18 10.23 9.99 10.13 14416 20091012 TIE 10.22 10.38 10.18 10.22 15485 20091013 TIE 10.21 10.25 10.04 10.17 17090 20091014 TIE 10.31 10.55 10.22 10.53 33450 20091015 TIE 10.4 10.65 10.36 10.58 21269 20091016 TIE 10.42 10.51 10.17 10.27 23065 20091019 TIE 10.38 10.58 10.331 10.49 17352 20091020 TIE 10.61 10.62 10.25 10.43 22995 20091021 TIE 10.39 10.43 10.03 10.06 35452 20091022 TIE 9.99 10.05 9.62 9.94 36596 20091023 TIE 10.03 10.07 9.46 9.5 33822 20091026 TIE 9.6 9.8 9.23 9.25 28959 20091027 TIE 9.32 9.406 9 9.02 25428 20091028 TIE 9 9.05 8.385 8.41 42766 20091105 TIE 9.02 9.44 8.91 9.44 42742 20091106 TIE 9.31 9.62 9.12 9.19 35973 20091109 TIE 9.29 9.61 9.29 9.61 26100 20091110 TIE 9.58 9.6 9.28 9.49 20811 20091111 TIE 9.65 9.65 9.4 9.52 18701 20091112 TIE 9.43 9.52 9.16 9.21 20027 20091113 TIE 9.21 9.4 9.16 9.32 14891 20091116 TIE 9.7 10.28 9.55 10.25 50529 20091117 TIE 10.19 10.35 10.05 10.33 30944 20091118 TIE 10.33 10.41 10.081 10.19 23807 20091119 TIE 10.09 10.09 9.71 9.92 25575 20091120 TIE 9.79 9.98 9.6 9.96 - ---- - -29.39 27.87 28.25 173538 20090930 AET 28.14 28.49 27.34 27.83 102525 20091001 AET 27.77 28.38 27.54 27.58 63622 20091002 AET 27.33 27.5 26.5 26.73 62374 20091005 AET 27.04 27.06 26.47 26.62 59569 20091006 AET 26.84 26.84 26.22 26.26 120039 20091007 AET 26.52 27.28 26.4 27.06 79911 20091008 AET 26.1 26.38 25.53 25.86 124727 20091009 AET 25.91 26.48 25.86 25.96 96907 20091012 AET 26.22 26.64 26.13 26.42 60241 20091013 AET 26.38 26.48 25.35 25.54 93251 20091014 AET 25.92 26.24 25.65 26.03 68248 20091015 AET 26.08 26.08 25.41 25.72 73966 20091016 AET 25.7 25.86 25.19 25.22 58039 20091019 AET 25.23 25.57 24.94 25.25 67996 20091020 AET 25.31 25.95 25.28 25.6 75503 20091021 AET 26.15 26.65 25.28 25.32 66565 20091022 AET 25.44 25.85 25.31 25.62 51312 20091023 AET 25.9 26.18 25.9 26.07 71399 20091026 AET 26.13 26.29 25.07 25.27 77172 20091027 AET 25.26 26.58 25.15 26.18 83004 20091028 AET 26.06 26.06 25.23 25.32 69177 20091105 AET 28.05 28.75 28.04 28.6 70321 20091106 AET 28.48 29.22 28.36 29.16 63680 20091109 AET 28.75 29.98 28.21 29.82 93573 20091110 AET 29.69 29.96 29.42 29.8 53320 20091111 AET 30.09 30.09 29.28 29.87 61107 20091112 AET 29.95 29.98 29.18 29.31 47022 20091113 AET 29.39 29.82 29.31 29.43 40609 20091116 AET 29.59 29.98 29.39 29.65 50054 20091117 AET 29.46 29.73 29.15 29.27 44965 20091118 AET 29.06 29.48 29 29.21 42037 20091119 AET 28.99 29.08 28.07 28.69 52862 20091120 AET 28.55 28.82 28.25 28.4 53483 20091123 AET 28.85 29.66 28.81 29.48 45361 20091124 AET 29.5 29.86 28.99 29.76 40258 20091125 AET 29.5 29.88 29.41 29.76 25470 20091127 AET 28.76 29.62 28.62 29.44 19264 20091130 AET 29.67 29.67 28.61 29.11 47522 20091201 AET 29.24 29.96 29.11 29.82 37933 20091202 AET 29.89 29.91 29.44 29.76 36029 20091203 AET 29.8 29.98 28.59 28.65 44895 20091204 AET 29 29.82 28.76 28.98 62553 20091207 AET 29 30.42 28.85 29.89 62895 20091208 AET 29.63 30.77 29.51 30.47 69016 20091209 AET 30.92 31.26 30.2 30.47 75999 20091210 AET 30.59 32.19 30.59 32.04 99056 20091211 AET 31.65 32.55 31.65 31.76 59091 20091214 AET 32 33.19 32 32.4 68733 20091215 AET 32.13 33.39 32.13 33.25 68459 20091216 AET 33.53 34.19 33.17 33.5 69521 20091217 AET 33.56 33.56 32.17 32.77 78497 20091218 AET 32.95 33 32.36 32.51 68159 20091221 AET 32.64 34.91 32.64 34.04 111345 20091222 AET 34.08 34.44 33.89 33.93 46154 20091223 AET 34.11 34.34 33.69 33.76 38978 20091224 AET 34.11 34.2 33.36 33.78 21711 20091228 AET 33.88 34.02 33.21 33.44 24004 20091229 AET 33.36 33.68 32.68 32.86 37801 20091230 AET 32.58 32.75 31.94 32.15 62459 20091231 AET 32.12 32.4 31.61 31.7 25070 20100104 AET 32.06 33.08 31.87 33 56719 20100105 AET 32.94 33.1 32.26 32.53 45735 20100106 AET 32.5 32.75 32.25 32.4 43030 20100107 AET 31.91 33.55 31.75 33.43 61816 20100108 AET 33.34 33.37 32.54 32.7 52264 20100111 AET 32.77 33.2 32.6 32.74 36740 20100112 AET 32.63 32.76 30.31 30.61 195432 20100113 AET 30.5 31.09 29.62 30.75 104662 20100114 AET 30.43 31.44 30.41 31.41 66303 20100115 AET 31.25 32.01 30.95 31.36 97940 20100119 AET 32.3 33.25 32.2 32.66 130450 20100120 AET 33.1 33.65 32.05 32.48 110077 20100121 AET 32.58 32.77 31.55 31.88 78377 20100122 AET 31.68 32.31 31.17 31.3 70000 20100125 AET 31.73 31.79 30.85 30.97 54316 20100126 AET 30.84 30.84 30.17 30.5 75769 20100127 AET 30.28 31.08 30.06 30.43 62549 20100128 AET 30.56 31.05 30.1 30.36 66268 20100129 AET 30.54 30.54 29.79 29.97 58836 20100201 AET 30.09 30.4 29.25 29.77 71412 20100202 AET 29.71 30.38 29.5 30.28 52914 20100203 AET 30.12 30.48 29.54 30.33 55450 20100204 AET 30.11 30.23 29.17 29.23 61082 20100205 AET 28.78 30.38 28.75 29.61 127514 20100208 AET 30.09 30.33 29.17 29.2 53951 20100209 AET 29.57 29.7 28 28.97 99612 20100210 AET 28.83 29.07 27.94 28.65 87251 20100211 AET 28.65 28.9 28.3 28.85 39153 20100212 AET 28.55 28.7 28.12 28.63 55365 20100216 AET 28.89 29 28.14 28.75 51374 20100217 AET 28.88 30 28.83 29.61 75200 20100218 AET 29.16 29.9 29.15 29.74 47634 20100219 AET 29.3 29.64 28.86 28.93 53612 20100222 AET 28.68 29.91 28.6 29.35 - ---- - -SVU 15.41 15.41 15.15 15.19 35189 20090918 SVU 15.21 15.51 15.14 15.46 34116 20090921 SVU 15.41 15.51 15.16 15.34 27323 20090922 SVU 15.43 15.5 15.25 15.4 18041 20090923 SVU 15.34 15.73 15.15 15.34 22590 20090924 SVU 15.32 15.62 15.25 15.31 23519 20090925 SVU 15.31 15.63 15.2 15.24 33402 20090928 SVU 15.25 15.35 15.03 15.09 32711 20090929 SVU 15.12 15.37 14.93 15.2 27594 20090930 SVU 15.34 15.35 14.82 15.06 36408 20091001 SVU 15 15.09 14.59 14.72 35940 20091002 SVU 14.71 14.74 14.4 14.47 24230 20091005 SVU 14.44 14.75 14.4 14.66 21279 20091006 SVU 14.71 15.04 14.63 14.68 27463 20091007 SVU 14.72 14.96 14.58 14.92 25065 20091008 SVU 14.98 15.76 14.96 15.65 43469 20091009 SVU 15.05 15.37 14.91 15.2 33709 20091012 SVU 15.23 16.11 15.2 16.07 50807 20091013 SVU 15.34 15.63 15.3 15.46 55762 20091014 SVU 15.52 15.63 15.425 15.62 44950 20091015 SVU 15.61 16.2 15.45 16.2 75731 20091016 SVU 16.06 17.15 16.02 17 88719 20091019 SVU 17.01 17.589 16.86 16.93 93352 20091020 SVU 16.81 17.48 16.67 17.2 114499 20091021 SVU 17.12 17.1925 16.57 16.59 60375 20091022 SVU 16.57 16.95 16.15 16.82 50827 20091023 SVU 16.95 16.97 16.3 16.55 37574 20091026 SVU 16.54 16.74 16.25 16.35 30807 20091027 SVU 16.34 16.41 15.99 16.01 46834 20091028 SVU 16.01 16.35 15.84 15.85 45493 20091105 SVU 15.84 16.33 15.83 16.12 22956 20091106 SVU 16.06 16.56 16.03 16.52 27680 20091109 SVU 16.62 17.02 16.5 17 29999 20091110 SVU 16.84 17.07 16.82 16.83 29050 20091111 SVU 16.85 16.91 16.3 16.39 55984 20091112 SVU 16.46 16.58 15.88 15.9 57555 20091113 SVU 15.94 16.11 15.78 15.9 38420 20091116 SVU 15.93 16.04 15.68 15.81 41567 20091117 SVU 15.72 15.86 15.49 15.7 31462 20091118 SVU 15.71 15.71 15.45 15.53 23623 20091119 SVU 15.45 15.49 15.08 15.13 31730 20091120 SVU 15.09 15.15 14.9 14.94 37522 20091123 SVU 15.12 15.19 14.93 14.95 39790 20091124 SVU 14.98 15 14.6768 14.77 48388 20091125 SVU 14.77 14.89 14.6 14.88 51072 20091127 SVU 14.43 14.67 14.35 14.42 27493 20091130 SVU 14.08 14.18 13.72 13.83 85740 20091201 SVU 13.89 14.35 13.87 14.3 55206 20091202 SVU 14.31 14.45 14.14 14.26 31331 20091203 SVU 14.24 14.3 13.95 14.07 34673 20091204 SVU 14.23 14.58 14.11 14.5 44204 20091207 SVU 14.49 14.68 14.33 14.44 36986 20091208 SVU 13.91 14.17 13.1 13.18 84344 20091209 SVU 13.24 13.27 12.83 12.97 51551 20091210 SVU 13.04 13.33 13.04 13.24 50189 20091211 SVU 13.35 13.49 13.31 13.39 28457 20091214 SVU 13.47 13.5 13.17 13.23 25145 20091215 SVU 13.23 13.23 12.8 12.91 39162 20091216 SVU 12.91 13.29 12.82 12.83 56814 20091217 SVU 12.83 13 12.57 12.57 47891 20091218 SVU 12.64 12.7 12.4 12.48 55445 20091221 SVU 12.59 12.82 12.51 12.66 30735 20091222 SVU 12.77 12.88 12.67 12.82 30155 20091223 SVU 12.85 12.88 12.65 12.83 18313 20091224 SVU 12.86 12.95 12.76 12.9 8650 20091228 SVU 12.97 12.97 12.79 12.9 15237 20091229 SVU 12.93 12.93 12.625 12.63 20298 20091230 SVU 12.59 12.72 12.57 12.66 18302 20091231 SVU 12.65 12.92 12.63 12.71 31982 20100104 SVU 12.8 13 12.78 12.96 43914 20100105 SVU 12.99 13 12.6 12.74 50151 20100106 SVU 12.74 12.98 12.74 12.87 38132 20100107 SVU 12.82 12.98 12.73 12.9 30190 20100108 SVU 12.9 12.96 12.78 12.87 30905 20100111 SVU 12.95 12.95 12.68 12.92 45215 20100112 SVU 13.81 14.14 13.36 13.67 167377 20100113 SVU 13.76 14.0499 13.42 13.86 59558 20100114 SVU 13.9 14.4 13.81 14.33 80407 20100115 SVU 14.38 14.5 13.98 14.32 52679 20100119 SVU 14.42 14.95 14.4 14.81 74295 20100120 SVU 14.71 15.675 14.63 15.62 86914 20100121 SVU 15.63 15.78 15.17 15.22 76088 20100122 SVU 15.23 15.54 14.99 15.42 70106 20100125 SVU 15.53 15.59 15.01 15.08 53692 20100126 SVU 15.02 15.04 14.75 14.75 33486 20100127 SVU 14.76 14.94 14.525 14.94 53385 20100128 SVU 14.94 15.12 14.66 15.05 50511 20100129 SVU 15.12 15.15 14.62 14.71 43821 20100201 SVU 14.72 14.99 14.72 14.84 33537 20100202 SVU 14.89 15.0995 14.78 15.06 39829 20100203 SVU 15 15.02 14.65 14.73 34319 20100204 SVU 14.62 14.83 14.41 14.44 44919 20100205 SVU 14.39 14.6 14.3 14.59 38565 20100208 SVU 14.61 14.635 14.32 14.42 26670 20100209 SVU - ---- - -IBM 128.23 128.75 127.65 128.25 49047 20100401 IBM 128.95 129.31 127.55 128.25 49806 20100405 IBM 128.38 129.8 128.14 129.35 41188 20100406 IBM 128.68 129.3 128.05 128.93 39264 20100407 IBM 128.53 129.27 128.01 128.48 51573 20100408 IBM 128.04 128.23 127.2 127.61 60068 20100409 IBM 127.88 128.87 127.12 128.76 51865 20100412 IBM 128.57 128.956 128.24 128.36 39941 20100413 IBM 128.26 129.435 127.84 129.03 68218 20100414 IBM 129.73 131.42 129.46 131.25 85458 20100415 IBM 130.53 131.14 130.1902 130.89 64253 20100416 IBM 130.68 132.17 130.25 130.63 95497 20100419 IBM 130.38 132.28 130.38 132.23 113536 20100420 IBM 129.2 130.33 128.26 129.69 152185 20100421 IBM 129.87 130.27 128.5 128.99 75600 20100422 IBM 128.64 129.36 127.77 129.13 60186 20100423 IBM 129.08 130.1 128.71 129.99 61973 20100426 IBM 129.76 131.04 129.54 130.73 52854 20100427 IBM 129.9 132 128.71 128.82 109175 20100428 IBM 129.4 130.47 129.03 130.1 71236 20100429 IBM 130.55 131.21 130.15 130.46 57868 20100430 IBM 130.43 130.636 128.84 129 62666 20100503 IBM 129.39 130.14 128.8 129.6 49920 20100504 IBM 128.89 128.93 126.5754 128.12 82852 20100505 IBM 127.12 128.23 126.87 127.46 60728 20100506 IBM 126.29 127.93 116 123.92 131696 20100507 IBM 123.09 124.39 120 122.1 105853 20100510 IBM 126.27 126.67 125.06 126.27 84642 20100511 IBM 125.21 128.42 125.15 126.89 64997 20100512 IBM 127.16 132.85 127.01 132.68 166297 20100513 IBM 130.93 133.1 130.85 131.48 104983 20100514 IBM 131.06 131.67 129.41 131.19 99205 20100517 IBM 130.68 131.76 128.7 130.44 89247 20100518 IBM 131.26 131.99 129.9 129.95 93321 20100519 IBM 129.37 130.5 127.82 128.86 86698 20100520 IBM 127.22 127.96 123.68 123.8 131781 20100521 IBM 122.16 125.61 121.4 125.42 126395 20100524 IBM 125.26 126.02 124.04 124.45 68678 20100525 IBM 121.47 124.95 121.47 124.52 94988 20100526 IBM 124.89 125.94 123 123.23 90859 20100527 IBM 124.86 126.39 124.77 126.39 77265 20100528 IBM 125.96 126.2794 124.29 125.26 74223 20100601 IBM 124.69 126.88 124.2 124.34 71360 20100602 IBM 124.85 127.5 124.35 127.41 77055 20100603 IBM 127.75 128.22 126.46 127.96 66452 20100604 IBM 126.37 127.1 124.67 125.28 96691 20100607 IBM 125.57 125.86 124.13 124.13 69513 20100608 IBM 124.26 124.46 122.82 123.72 83991 20100609 IBM 124.74 125.84 123.58 123.9 78003 20100610 IBM 125.99 128.22 125.8 127.68 74796 20100611 IBM 126.73 128.8 126.44 128.45 58270 20100614 IBM 128.5 129.97 128.49 128.5 67531 20100615 IBM 128.8 129.95 128.37 129.79 66526 20100616 IBM 128.34 130.68 128.34 130.35 64009 20100617 IBM 130.07 131.03 129.86 130.98 55751 20100618 IBM 131.02 131.25 130.13 130.15 95815 20100621 IBM 131.42 131.94 130.22 130.65 68578 20100622 IBM 130.37 131.47 129.07 129.3 60306 20100623 IBM 129.25 131.47 129.09 130.11 68557 20100624 IBM 129.57 129.73 127.7 128.19 55655 20100625 IBM 128.54 129.095 127.12 127.12 104206 20100628 IBM 127.65 129.47 127.22 128.98 63351 20100629 IBM 127.35 128.4 124.12 125.09 93787 20100630 IBM 124.83 125.22 123 123.48 80179 20100701 IBM 123.85 124.21 121.61 122.57 97422 20100702 IBM 123.29 123.29 120.61 121.86 64544 20100706 IBM 123.67 124.63 122.17 123.46 63487 20100707 IBM 123.89 127.12 123.47 127 70902 20100708 IBM 127.37 128.15 126.74 127.97 54399 20100709 IBM 127.9 128.2 127.29 127.96 38984 20100712 IBM 127.37 128.83 127.16 128.67 42068 20100713 IBM 128.97 130.98 128.69 130.48 66876 20100714 IBM 129.32 131.6 129.14 130.72 66071 20100715 IBM 129.87 130.92 129.55 130.72 61875 20100716 IBM 129.96 130.15 127.85 128.03 70028 20100719 IBM 128.67 130.38 128.37 129.79 83885 20100720 IBM 122.97 126.56 122.93 126.55 163403 20100721 IBM 126.44 126.5 124.62 125.27 86154 20100722 IBM 126.32 127.78 126.05 127.47 69090 20100723 IBM 127.3 128.8 127 128.38 50779 20100726 IBM 127.83 128.43 127.14 128.41 51722 20100727 IBM 128.78 129.17 127.89 128.63 46485 20100728 IBM 128.67 129.35 127.88 128.43 42526 20100729 IBM 129.06 129.5 127.14 128.02 89973 20100730 IBM 127.43 128.98 127.04 128.4 60258 20100802 IBM 129.32 131.2 129.25 130.76 64374 20100803 - ---- - -14.63 14.71 13.92 13.93 38025 20091028 JNS 13.88 14.0196 12.9298 12.93 51663 20091105 JNS 13.2 13.33 12.89 13.26 44846 20091106 JNS 13.01 13.34 12.87 13.32 24762 20091109 JNS 13.52 14.11 13.49 13.98 28337 20091110 JNS 13.96 14.12 13.66 13.77 18584 20091111 JNS 13.93 14.2 13.9 14.01 24271 20091112 JNS 14.01 14.24 13.6 13.61 24415 20091113 JNS 13.66 13.9 13.48 13.72 16561 20091116 JNS 13.91 14.17 13.87 14.01 26405 20091117 JNS 13.93 14.09 13.85 14.04 12403 20091118 JNS 14.04 14.11 13.77 13.8 13494 20091119 JNS 13.69 13.76 13.26 13.47 15474 20091120 JNS 13.35 13.42 13.06 13.21 16535 20091123 JNS 13.46 13.59 13.08 13.35 28787 20091124 JNS 13.28 13.35 13 13.27 21086 20091125 JNS 13.46 13.46 13.07 13.27 16080 20091127 JNS 12.78 12.92 12.42 12.7 11976 20091130 JNS 12.77 13.14 12.6 13.09 32103 20091201 JNS 13.28 13.28 12.815 13.1 31939 20091202 JNS 13.21 13.23 12.77 12.87 28060 20091203 JNS 12.9 13.07 12.56 12.6 26791 20091204 JNS 12.91 13.17 12.54 12.97 32266 20091207 JNS 12.88 13.04 12.71 12.76 15436 20091208 JNS 12.66 12.71 12.49 12.66 22026 20091209 JNS 12.63 12.78 12.45 12.71 19276 20091210 JNS 12.78 12.96 12.71 12.8 14487 20091211 JNS 12.73 13.05 12.73 13.01 15562 20091214 JNS 13 13.07 12.76 12.97 13839 20091215 JNS 12.81 12.96 12.76 12.82 11888 20091216 JNS 12.94 13.28 12.915 13.21 18180 20091217 JNS 13.11 13.19 12.94 12.95 16484 20091218 JNS 13.02 13.17 12.87 13.17 18985 20091221 JNS 13.18 13.41 13.13 13.36 14154 20091222 JNS 13.38 13.49 13.3462 13.42 10141 20091223 JNS 13.39 13.5 13.15 13.31 10176 20091224 JNS 13.34 13.54 13.3 13.5 3608 20091228 JNS 13.5 13.76 13.41 13.47 7621 20091229 JNS 13.56 13.61 13.44 13.52 5262 20091230 JNS 13.43 13.58 13.32 13.44 5232 20091231 JNS 13.49 13.67 13.4 13.45 7750 20100104 JNS 13.61 13.94 13.46 13.83 13910 20100105 JNS 13.75 14.32 13.62 14.28 22689 20100106 JNS 14.26 14.47 14.2 14.33 18168 20100107 JNS 14.36 14.46 13.88 14.05 20523 20100108 JNS 13.93 14.34 13.86 14.31 22923 20100111 JNS 14.36 15.19 14.36 15 40448 20100112 JNS 14.86 14.97 14.45 14.55 18291 20100113 JNS 14.61 14.72 14.51 14.63 10937 20100114 JNS 14.57 14.81 14.27 14.67 13236 20100115 JNS 14.69 14.83 14.42 14.5 17475 20100119 JNS 14.47 14.69 14.26 14.69 17607 20100120 JNS 14.56 14.7 14.2 14.35 18350 20100121 JNS 14.3 14.56 13.79 13.86 35741 20100122 JNS 13.86 13.93 12.99 13.01 36890 20100125 JNS 13.23 13.61 13.18 13.42 31845 20100126 JNS 13.27 13.42 12.97 12.98 23317 20100127 JNS 12.68 13.26 12.37 13.18 59471 20100128 JNS 13.01 13.72 12.22 12.93 63979 20100129 JNS 13.03 13.25 12.15 12.21 43829 20100201 JNS 12.19 12.54 12.19 12.51 22698 20100202 JNS 12.55 12.64 12.14 12.14 45994 20100203 JNS 12.06 12.25 12 12.12 49567 20100204 JNS 12.39 12.39 11.49 11.66 84584 20100205 JNS 11.66 12.035 11.52 11.98 76422 20100208 JNS 11.95 12.22 11.65 11.67 35197 20100209 JNS 11.89 12.02 11.61 11.83 36434 20100210 JNS 11.81 12.11 11.76 11.94 18398 20100211 JNS 11.89 12.01 11.73 11.98 16290 20100212 JNS 11.85 11.97 11.77 11.95 22120 20100216 JNS 12.08 12.48 12.06 12.39 22109 20100217 JNS 12.43 12.5 12.28 12.41 18595 20100218 JNS 12.32 12.46 12.17 12.41 23764 20100219 JNS 12.37 12.55 12.34 12.41 16143 20100222 JNS 12.47 12.49 12.3 12.36 16081 20100223 JNS 12.29 12.38 11.98 12.09 21715 20100224 JNS 12.24 12.38 12.11 12.21 18019 20100225 JNS 12.02 12.12 11.78 11.99 38128 20100226 JNS 12.05 12.51 11.97 12.5 27597 20100301 JNS 12.53 12.92 12.5 12.91 25409 20100302 JNS 12.95 13.27 12.85 13.04 20816 20100303 JNS 13.12 13.48 13.08 13.24 23877 20100304 JNS 13.24 13.41 13.15 13.27 14857 20100305 JNS 13.38 13.74 13.36 13.67 27229 20100308 JNS 13.66 13.93 13.58 13.7 22704 20100309 JNS 13.58 13.9 13.4 13.78 26433 20100310 JNS 13.82 13.98 13.76 13.95 23385 20100311 JNS 13.64 13.98 13.54 13.77 15830 20100312 JNS 13.83 14.02 13.68 13.98 18788 20100315 JNS 13.98 14.03 13.75 14 24969 20100316 JNS 14.05 14.1 13.87 14 14858 20100317 JNS 14.07 14.4 14.07 14.35 26312 20100318 JNS 14.26 14.4 14.23 14.37 16775 20100319 JNS 14.31 14.41 14.01 14.02 24438 20100322 JNS - ---- - -15.32 14.642 15.26 68199 20100726 GNW 15.25 15.69 15.12 15.55 74860 20100727 GNW 15.79 15.88 15.52 15.65 72642 20100728 GNW 15.51 15.8 15.45 15.56 62248 20100729 GNW 15.66 16.1 15.18 15.79 136354 20100730 GNW 14.59 14.7 13.22 13.58 372169 20100802 GNW 13.73 13.76 13.1 13.67 158335 20100803 GNW 13.55 13.69 13.19 13.26 101763 20100804 GNW 13.31 13.4 12.73 12.83 168259 20100805 GNW 12.8 13.35 12.58 13.24 144633 20100806 GNW 13.08 13.24 12.75 13.05 136873 20100809 GNW 13.18 13.24 12.94 13.18 54098 20100810 GNW 12.95 13.22 12.79 13.12 85306 20100811 GNW 12.75 12.87 12.28 12.37 96906 20100812 GNW 12.04 12.25 11.75 11.89 126207 20100813 GNW 11.91 12.11 11.8 11.9 85609 20100816 GNW 12.04 12.295 11.95 12.03 69250 20100817 GNW 12.19 12.41 11.96 11.97 69573 20100819 GNW 11.92 12.03 11.53 11.54 73366 20100820 GNW 11.42 11.535 11.21 11.36 66282 20090821 GOOG 464.84 466.09 462.65 465.24 35643 20090824 GOOG 467.08 470.09 464.425 468.73 24593 20090825 GOOG 469.09 474.35 468.72 471.37 23430 20090826 GOOG 472.6 473 466.7 468 19884 20090827 GOOG 466.58 468.58 460.73 466.06 20000 20090828 GOOG 469.02 472.37 463.38 464.75 17718 20090831 GOOG 459.56 461.86 458 461.67 19579 20090901 GOOG 459.95 466.82 454.42 455.761 25950 20090902 GOOG 454.5 458.33 452.59 453.01 18065 20090903 GOOG 456.32 458.25 455 457.52 16463 20090904 GOOG 458.07 462.6 455.78 461.3 14998 20090909 GOOG 459.34 466.27 458.8 463.97 21954 20090910 GOOG 466.01 470.94 462 470.94 25353 20090911 GOOG 470.71 473.3 467.63 472.14 19028 20090914 GOOG 470.25 476.8 470.05 475.12 19776 20090915 GOOG 475.12 478.91 472.71 477.54 23986 20090916 GOOG 479.92 489.37 478.48 488.29 25873 20090917 GOOG 490.66 497.37 487.15 491.72 44834 20090918 GOOG 496.86 496.98 491.23 491.46 32842 20090921 GOOG 486.22 498.9 486.22 497 21175 20090922 GOOG 500.35 501.99 497.81 499.06 30418 20090923 GOOG 500.92 507 497.71 498.46 27046 20090924 GOOG 500.53 501.41 493 496.77 25286 20090925 GOOG 495.48 499.93 492 492.48 20520 20090928 GOOG 495 501.5 493.295 498.53 18431 20090929 GOOG 499.15 499.75 493.01 498.53 20993 20090930 GOOG 499.76 500.14 487.24 495.85 31417 20091001 GOOG 493.99 496.47 487 487.2 28162 20091002 GOOG 483.79 491.74 482.6 484.58 26008 20091005 GOOG 487.67 492.43 483.34 488.52 21264 20091006 GOOG 492.37 499.37 491.7001 498.74 27329 20091007 GOOG 498.97 518.99 497.81 517.54 48776 20091008 GOOG 519.58 523.25 513.34 514.18 43065 20091009 GOOG 516.435 521.51 514.5 516.25 27398 20091012 GOOG 523 525.76 519.3201 524.04 33243 20091013 GOOG 525.02 527.46 521.38 526.11 30422 20091014 GOOG 532.26 535.58 530 535.32 32650 20091015 GOOG 533.74 536.9 527.27 529.91 61003 20091016 GOOG 547.16 554.75 544.53 549.85 88457 20091019 GOOG 553.09 553.6 548.73 552.09 32201 20091020 GOOG 551.64 552.95 540.7 551.72 40444 20091021 GOOG 550.48 559.35 549 551.1 36731 20091022 GOOG 550.69 555 548 554.09 23370 20091023 GOOG 554.99 557.89 551.2 553.69 23931 20091026 GOOG 556.55 561.64 550.89 554.21 29737 20091027 GOOG 552.56 554.56 544.16 548.29 32180 20091028 GOOG 546.51 550 538.25 540.3 25686 20091105 GOOG 543.94 549.77 542.664 548.65 18480 20091106 GOOG 547.72 551.78 545.5 551.1 18267 20091109 GOOG 554.99 562.58 554.23 562.51 26514 20091110 GOOG 563.39 568.78 562 566.76 22314 20091111 GOOG 570.5 573.5 565.86 570.56 23218 20091113 GOOG 569.4 572.51 566.61 572.05 16680 20091116 GOOG 573.58 576.99 572.78 576.28 21991 20091117 GOOG 574.06 577.5 573.72 577.49 19207 20091118 GOOG 577.49 578.78 572.07 576.65 15501 20091119 GOOG 573.89 574 570 572.99 21683 20091120 GOOG 569.99 571.6 569.4 569.964 20062 20091123 GOOG 576.41 586.6 575.86 582.35 25485 20091124 GOOG 582.5 584.29 576.54 583.09 16086 20091125 GOOG 586.44 587.0599 582.69 585.74 14614 20091127 GOOG 571.58 582.46 570.97 579.76 13845 20091130 GOOG 579.97 583.67 577.11 583 17252 20091201 GOOG 588.19 591.22 583 589.87 23212 20091202 GOOG 590.98 593.01 586.22 587.51 16652 20091203 GOOG 588.89 591.45 585 585.74 14293 20091204 GOOG 593.04 594.832 579.18 585.01 25140 20091207 GOOG 584.14 - ---- - -TXT 16.31 17.18 16.23 17.17 68334 20100708 TXT 17.12 17.3 16.66 17.04 50855 20100709 TXT 17.07 17.89 17.05 17.8 54789 20100712 TXT 17.8 18.03 17.48 17.68 39380 20100713 TXT 18.41 18.9 18.2 18.39 49484 20100714 TXT 18.25 18.5 17.9 18.25 42276 20100715 TXT 18.28 18.47 17.625 18.26 40429 20100716 TXT 18.09 18.14 17.29 17.34 54499 20100719 TXT 17.53 17.64 17.28 17.57 38276 20100720 TXT 17.16 18.19 17.1 18.08 42204 20100721 TXT 19.7 19.85 18.975 19.65 155576 20100722 TXT 19.99 20.37 19.79 20.22 74578 20100723 TXT 20.02 20.79 19.77 20.77 53000 20100726 TXT 20.88 21.21 20.65 21.17 44362 20100727 TXT 21.36 21.4 20.35 20.71 52125 20100728 TXT 20.71 20.97 20.39 20.63 49929 20100729 TXT 20.86 20.99 20.4 20.69 37648 20100730 TXT 20.26 20.86 20.23 20.76 37197 20100802 TXT 21.25 21.33 20.33 21.29 47068 20100803 TXT 21.25 21.32 20.91 21.09 22547 20100804 TXT 21.09 21.52 21.05 21.48 31565 20100805 TXT 21.25 21.46 21.08 21.36 21589 20100806 TXT 20.93 21.23 20.6 20.82 46106 20100809 TXT 21.03 21.1 20.61 20.98 35235 20100810 TXT 20.61 20.615 19.95 20.12 60700 20100811 TXT 19.59 19.59 18.59 18.97 81755 20100812 TXT 18.51 18.78 18.37 18.43 72333 20100813 TXT 18.36 18.7 18.15 18.16 68450 20100816 TXT 18 18.22 17.83 17.86 61856 20100817 TXT 18.12 18.73 18 18.37 62777 20100819 TXT 18.4 18.8 18 18.15 56009 20100820 TXT 18 18.06 17.49 17.89 60308 20090821 UNH 28.72 29.05 28.27 28.92 81828 20090824 UNH 29.09 29.72 28.55 29.69 119079 20090825 UNH 29.77 30 29.18 29.92 102078 20090826 UNH 29.83 29.84 28.81 28.93 101440 20090827 UNH 28.82 29.21 28.52 28.94 77841 20090828 UNH 29.1 29.13 27.98 28.18 90744 20090831 UNH 27.97 28.79 27.7 28 76038 20090901 UNH 27.94 28.47 27.27 27.33 101709 20090902 UNH 27.37 29.13 27.36 28.66 143803 20090903 UNH 28.94 29.1 28.03 28.87 104795 20090904 UNH 28.8 29.25 28.55 28.88 58374 20090909 UNH 28.02 28.44 27.7 28.4 109749 20090910 UNH 28.15 29.18 28.05 29.11 91364 20090911 UNH 29.12 29.41 28.77 29.07 54305 20090914 UNH 28.85 29.17 28.43 28.76 73561 20090915 UNH 28.82 28.83 27.66 27.7 135709 20090916 UNH 27.95 29.34 27.81 29.29 141190 20090917 UNH 29.45 29.88 29.13 29.34 114612 20090918 UNH 28.89 29.26 28.41 28.58 156995 20090921 UNH 28.45 28.94 28.22 28.59 82583 20090922 UNH 28.72 28.78 27.51 27.58 129499 20090923 UNH 27.85 27.85 26.63 26.68 152269 20090924 UNH 26.73 27.04 25.98 26.03 139958 20090925 UNH 26.01 26.18 25.13 25.34 168390 20090928 UNH 25.44 26.09 25.36 25.8 87955 20090929 UNH 25.92 26.44 24.94 25.68 232162 20090930 UNH 25.15 25.6 24.52 25.04 229364 20091001 UNH 24.89 25.64 24.7 24.79 172111 20091002 UNH 24.68 24.91 23.95 24.28 112195 20091005 UNH 24.38 24.5 23.95 24.04 124358 20091006 UNH 24.46 24.59 23.82 24.38 111923 20091007 UNH 24.42 25.34 24.4 25.05 120816 20091008 UNH 24.29 24.43 23.5 24.16 245316 20091009 UNH 24.45 25.05 24.41 24.67 165554 20091012 UNH 24.81 25.52 24.81 25.23 139538 20091013 UNH 25.17 25.17 23.96 24.29 190105 20091014 UNH 24.62 24.93 24.35 24.87 98019 20091015 UNH 24.77 24.91 24.38 24.55 111235 20091016 UNH 24.71 24.9636 24.33 24.45 123669 20091019 UNH 24.57 24.99 24.41 24.92 102737 20091020 UNH 25.68 26.52 25.5 25.96 213930 20091021 UNH 25.97 26.07 25.03 25.12 119609 20091022 UNH 25.05 26 25.02 25.71 137571 20091023 UNH 26.1 26.22 25.6 25.85 82933 20091026 UNH 25.93 26.19 25.29 25.31 143477 20091027 UNH 25.3 26.8 25.19 26.5 204857 20091028 UNH 26.29 26.51 25.81 25.88 115060 20091105 UNH 27.95 28.38 27.67 28.21 119946 20091106 UNH 28.1 28.74 27.8 28.67 118920 20091109 UNH 28.31 29.24 28.2 29.13 117518 20091110 UNH 29 29.18 28.62 28.97 80632 20091111 UNH 28.99 29.43 28.66 29.37 87941 20091112 UNH 29.43 29.43 28.69 28.76 84073 20091113 UNH 28.88 29.35 28.85 29.08 62767 20091116 UNH 29.23 29.5 28.95 29.15 82814 20091117 UNH 28.96 29.18 28.79 28.97 61033 20091118 UNH 28.97 29.11 28.65 28.87 73275 20091119 UNH 28.66 28.72 27.87 28.63 69909 20091120 UNH 28.3 28.77 28.3 28.56 90091 20091123 UNH 28.94 29.58 28.93 29.08 96248 20091124 UNH 29.33 29.69 28.85 29.56 72410 20091125 UNH 29.58 29.74 29.37 - ---- - -110598 20091020 LSI 5.79 5.83 5.64 5.68 64299 20091021 LSI 5.62 5.77 5.5 5.51 87070 20091022 LSI 5.57 5.58 5.4 5.46 112487 20091023 LSI 5.56 5.63 5.31 5.35 103364 20091026 LSI 5.3 5.54 5.26 5.33 79343 20091027 LSI 5.33 5.41 5.09 5.12 115031 20091028 LSI 5.19 5.21 4.94 4.99 98602 20091105 LSI 5.19 5.22 5.04 5.2 74509 20091106 LSI 5.09 5.24 5.07 5.22 67337 20091109 LSI 5.27 5.48 5.25 5.46 67158 20091110 LSI 5.44 5.53 5.33 5.5 68937 20091111 LSI 5.54 5.67 5.49 5.56 58131 20091112 LSI 5.54 5.61 5.47 5.53 47453 20091113 LSI 5.49 5.62 5.46 5.59 40730 20091116 LSI 5.51 5.81 5.5 5.79 138971 20091117 LSI 5.71 5.86 5.7 5.85 57724 20091118 LSI 5.86 5.88 5.69 5.7 43437 20091119 LSI 5.49 5.57 5.38 5.51 110680 20091120 LSI 5.48 5.51 5.3505 5.47 53060 20091123 LSI 5.55 5.6 5.44 5.5 44806 20091124 LSI 5.45 5.55 5.38 5.45 55644 20091125 LSI 5.47 5.55 5.38 5.53 43284 20091127 LSI 5.37 5.48 5.3 5.42 27090 20091130 LSI 5.44 5.48 5.27 5.29 73631 20091201 LSI 5.4 5.6 5.38 5.58 73159 20091202 LSI 5.54 5.69 5.54 5.63 50662 20091203 LSI 5.65 5.7 5.59 5.62 38240 20091204 LSI 5.76 5.83 5.57 5.76 91471 20091207 LSI 5.76 5.79 5.66 5.68 50174 20091208 LSI 5.62 5.71 5.54 5.55 90223 20091209 LSI 5.54 5.62 5.4999 5.57 86862 20091210 LSI 5.55 5.66 5.49 5.57 66288 20091211 LSI 5.59 5.59 5.46 5.57 47554 20091214 LSI 5.59 5.65 5.54 5.64 30317 20091215 LSI 5.67 5.67 5.51 5.53 70626 20091216 LSI 5.53 5.7 5.5 5.6 39186 20091217 LSI 5.57 5.61 5.41 5.47 50401 20091218 LSI 5.55 5.68 5.51 5.61 89933 20091221 LSI 5.6 5.97 5.6 5.96 106236 20091222 LSI 5.88 6 5.87 5.9 72016 20091223 LSI 5.94 6.05 5.88 5.99 71226 20091224 LSI 5.97 6.14 5.97 6.03 26447 20091228 LSI 6.04 6.11 5.95 6 60300 20091229 LSI 6 6.06 5.82 5.96 54032 20091230 LSI 6.01 6.01 5.89 6 40642 20091231 LSI 5.98 6.05 5.9 6.01 58815 20100104 LSI 6.05 6.23 6.03 6.08 113356 20100105 LSI 6.11 6.21 6.06 6.11 70197 20100106 LSI 6.17 6.17 5.95 6.03 88475 20100107 LSI 6 6.08 5.92 5.96 103382 20100108 LSI 5.96 6.03 5.9 6.02 78159 20100111 LSI 6.02 6.17 6.01 6.14 97474 20100112 LSI 6.07 6.07 5.86 5.94 70465 20100113 LSI 5.94 6.03 5.8 6.02 88099 20100114 LSI 6.03 6.04 5.93 5.97 76501 20100115 LSI 5.96 5.99 5.83 5.86 68870 20100119 LSI 5.88 5.99 5.84 5.97 62071 20100120 LSI 5.92 5.95 5.85 5.86 70312 20100121 LSI 5.98 6.2 5.93 6.08 175344 20100122 LSI 6 6.05 5.7 5.73 149158 20100125 LSI 5.7 5.86 5.7 5.8 76226 20100126 LSI 5.78 5.86 5.73 5.74 59256 20100127 LSI 5.74 6.05 5.7 6 150246 20100128 LSI 5.52 5.66 5.26 5.45 238843 20100129 LSI 5.54 5.55 4.88 4.99 274536 20100201 LSI 5.23 5.23 5.01 5.19 138848 20100202 LSI 5.2 5.23 5.09 5.12 136474 20100203 LSI 5.09 5.19 5.05 5.17 247991 20100204 LSI 5.08 5.14 4.955 5.02 246978 20100205 LSI 5 5.18 4.96 5.15 158904 20100208 LSI 5.12 5.24 5.07 5.14 93117 20100209 LSI 5.23 5.34 5.16 5.28 122833 20100210 LSI 5.33 5.39 5.27 5.36 92763 20100211 LSI 5.32 5.43 5.31 5.4 100043 20100212 LSI 5.32 5.43 5.29 5.39 115181 20100216 LSI 5.42 5.65 5.3917 5.63 114943 20100217 LSI 5.65 5.68 5.45 5.57 104414 20100218 LSI 5.53 5.59 5.48 5.56 90537 20100219 LSI 5.54 5.67 5.52 5.64 67257 20100222 LSI 5.72 5.74 5.55 5.59 58947 20100223 LSI 5.59 5.5912 5.42 5.52 71619 20100224 LSI 5.6 5.6 5.445 5.51 85068 20100225 LSI 5.41 5.46 5.28 5.46 80537 20100226 LSI 5.43 5.45 5.33 5.39 61629 20100301 LSI 5.42 5.54 5.4 5.51 53798 20100302 LSI 5.51 5.68 5.48 5.53 88641 20100303 LSI 5.57 5.62 5.46 5.51 75261 20100304 LSI 5.47 5.6 5.47 5.55 61063 20100305 LSI 5.63 5.68 5.54 5.64 67927 20100308 LSI 5.61 5.63 5.53 5.55 55922 20100309 LSI 5.54 5.58 5.47 5.47 65903 20100310 LSI 5.51 5.65 5.46 5.62 60436 20100311 LSI 5.56 5.58 5.42 5.53 100486 20100312 LSI 5.55 5.6 5.48 5.57 88272 20100315 LSI 5.54 5.58 5.48 5.56 80656 20100316 LSI 5.56 5.83 5.56 5.82 108139 20100317 LSI 6.01 6.55 5.96 6.34 414836 20100318 LSI 6.32 6.38 6.18 6.35 227092 20100319 LSI 6.38 6.52 6.29 6.41 212452 20100322 LSI 6.34 6.69 6.28 6.64 163351 20100323 LSI 6.68 6.73 6.58 6.65 107654 20100324 LSI 6.62 6.64 6.42 6.45 112689 20100325 LSI 6.54 6.64 6.45 6.46 - ---- - -46485 20100728 IBM 128.67 129.35 127.88 128.43 42526 20100729 IBM 129.06 129.5 127.14 128.02 89973 20100730 IBM 127.43 128.98 127.04 128.4 60258 20100802 IBM 129.32 131.2 129.25 130.76 64374 20100803 IBM 130.03 131.04 129.33 130.37 50919 20100804 IBM 130.46 131.5 129.85 131.27 45730 20100805 IBM 130.69 131.98 130.53 131.83 45231 20100806 IBM 130.41 130.48 128.76 130.14 61378 20100809 IBM 130.79 132.34 130.4 132 61353 20100810 IBM 131.18 132.49 130.77 131.84 54716 20100811 IBM 130.69 130.69 129.461 129.83 63180 20100812 IBM 128 128.78 127.52 128.3 51323 20100813 IBM 127.96 128.46 127.33 127.87 46705 20100816 IBM 127.47 128.23 126.96 127.77 40091 20100817 IBM 128.83 129.85 127.905 128.45 42985 20100819 IBM 128.97 129.59 128.02 128.9 54025 20100820 IBM 128.72 128.98 126.96 127.5 62462 20090821 ICE 96 96.22 93.94 95.94 18903 20090824 ICE 96.74 98.58 94.11 94.28 19766 20090825 ICE 94.84 96.29 92.23 93.37 16747 20090826 ICE 93.01 93.09 91.4 92.98 14481 20090827 ICE 92.89 93.49 91.01 91.3 14475 20090828 ICE 92.09 93.67 91.36 93.41 13655 20090831 ICE 91.99 94.09 90.78 93.8 11549 20090901 ICE 93.7 95.3 91.27 91.36 13004 20090902 ICE 90.74 92.98 90.41 90.59 9982 20090903 ICE 91.5 91.79 88.49 89.94 11940 20090904 ICE 89.9 90.62 87.2 89.56 14874 20090909 ICE 90.71 90.97 88.39 88.87 13997 20090910 ICE 88.71 89.41 86.5 89.36 15442 20090911 ICE 89.36 89.6 87.4 88.19 9978 20090914 ICE 87.43 90.22 86.66 90.22 10458 20090915 ICE 90.01 91.35 88.24 90.42 13896 20090916 ICE 90.57 95.26 90.35 95.04 21600 20090917 ICE 94.98 97.98 94.46 96.37 17812 20090918 ICE 96.97 99.1 95.41 97.63 17939 20090921 ICE 96.45 97.86 90.5 96.89 9270 20090922 ICE 98.11 99.39 95.5 98.85 12694 20090923 ICE 98.75 100.73 97.41 97.42 14448 20090924 ICE 97.53 97.53 92.24 93.03 16375 20090925 ICE 92.31 92.8986 90.31 91.05 11093 20090928 ICE 91.49 95.28 91.32 94.99 11771 20090929 ICE 95.44 96.5 94.75 95.04 9344 20090930 ICE 95.6 99 94.816 97.19 22532 20091001 ICE 96.42 97.45 92.01 93.84 19628 20091002 ICE 93 94.28 91 91.32 18475 20091005 ICE 93.24 95.05 91.8 94.99 13838 20091006 ICE 95.96 96.44 94.31 95.49 10260 20091007 ICE 95.28 95.54 93.03 94.09 11571 20091008 ICE 94.91 94.91 93.17 93.37 14832 20091009 ICE 93.46 96.35 93 95.96 12517 20091012 ICE 96.38 96.96 94.61 95.6 7748 20091013 ICE 94.9 96.3 94.41 95.75 7526 20091014 ICE 96.99 98.5 96.1 97.29 17027 20091015 ICE 96.4 98.5 96.12 98.25 7311 20091016 ICE 99.02 106.25 99 105.84 36298 20091019 ICE 106.01 107.27 104.23 106.03 22363 20091020 ICE 105.47 107.92 104.93 105.95 12877 20091021 ICE 105.52 109.59 105.25 106.43 13021 20091022 ICE 106.16 107.97 105.5 106.56 7562 20091023 ICE 106.96 106.96 104.1 104.54 8860 20091026 ICE 104.75 107.45 102.93 103.25 6894 20091027 ICE 103.65 104.41 102.48 102.78 7254 20091028 ICE 102.73 104.22 100.52 100.61 10504 20091105 ICE 100.88 104.71 100.88 104.53 10169 20091106 ICE 103.76 106.2899 102.7619 106.01 10864 20091109 ICE 107.49 108.9 106.36 107.92 8578 20091110 ICE 107.16 107.92 106.14 107.45 8324 20091111 ICE 108.07 109.94 107.3 108.13 9126 20091112 ICE 107.55 109.5 107.34 107.83 7344 20091113 ICE 107.51 108.99 106.75 108.53 5444 20091116 ICE 108.99 111.35 108.58 110.03 8741 20091117 ICE 110.56 111.02 108.86 109.27 5471 20091118 ICE 109.51 109.75 108.5 109.4 5067 20091119 ICE 108.6 108.94 105.5 106.76 9458 20091120 ICE 106.1 107.31 105.09 106.77 6043 20091123 ICE 107.99 110.51 107.59 108.6 7304 20091124 ICE 108.63 108.64 106.23 107.47 4726 20091125 ICE 107.36 108.47 107.03 107.92 4190 20091127 ICE 105.24 106.72 104.22 104.82 4749 20091130 ICE 105.07 106.96 104.48 106.79 7184 20091201 ICE 107.75 108.48 106.5 107.81 5483 20091202 ICE 107.59 109.76 106.3 106.62 8502 20091203 ICE 107.01 107.43 104.8 105.09 7616 20091204 ICE 106.62 107.24 102.83 105.1 8679 20091207 ICE 104.81 104.81 102.25 104.03 10113 20091208 ICE 103.68 105.11 103.17 105.04 7489 20091209 ICE 105.04 105.9499 103.9 105.35 7319 20091210 ICE 103.92 107.999 103.92 106 9378 20091211 ICE 107.2 109.97 106.5 109.49 11333 20091214 ICE - ---- - -22.71 24.48 141792 20100708 STI 24.96 24.96 24.05 24.67 82240 20100709 STI 24.55 25.54 24.46 25.46 54188 20100712 STI 25.24 25.48 24.8 25.18 33142 20100713 STI 25.54 26.365 25.5 26.18 63045 20100714 STI 25.93 25.93 24.98 25.46 69568 20100715 STI 25.58 25.58 24.42 25.19 68793 20100716 STI 24.82 24.82 23.13 23.31 108617 20100719 STI 23.38 23.53 22.59 23.37 64425 20100720 STI 22.81 23.08 22.44 23.07 96668 20100721 STI 23.46 23.86 22.32 22.42 92660 20100722 STI 24.01 24.89 23.65 24.58 122842 20100723 STI 24.36 25.15 24.02 25.04 71690 20100726 STI 25.18 26.42 24.88 26.38 87802 20100727 STI 26.68 27.05 26.16 26.27 72302 20100728 STI 26.1 26.3 25.83 25.99 47762 20100729 STI 26.25 26.42 25.51 25.96 59315 20100730 STI 25.53 26.13 25.42 25.95 44050 20100802 STI 26.6 26.76 26.19 26.63 47556 20100803 STI 26.49 26.7695 26.25 26.37 52466 20100804 STI 26.43 26.58 26 26.19 39665 20100805 STI 26.06 26.42 25.75 26.34 45802 20100806 STI 26.01 26.12 25.17 25.85 49495 20100809 STI 26 26.15 25.49 25.88 48330 20100810 STI 25.55 26.26 25.37 25.99 58689 20100811 STI 25.43 25.56 24.38 24.46 74825 20100812 STI 24.06 24.555 23.94 24.3 59428 20100813 STI 24.26 24.73 24.23 24.39 39538 20100816 STI 24.24 24.46 24.02 24.36 38629 20100817 STI 24.71 24.76 24.11 24.14 47747 20100819 STI 24.52 25.1 24.1875 24.22 70643 20100820 STI 24 24.24 23.59 24 53040 20090821 STJ 37.91 38.08 37.522 37.79 23219 20090824 STJ 38.02 38.13 37.54 37.92 13988 20090825 STJ 38 38.25 37.85 38.02 16751 20090826 STJ 38.78 39.63 38.45 38.65 41256 20090827 STJ 38.6 39 38.35 38.87 21273 20090828 STJ 39.01 39.08 38.5 38.85 21067 20090831 STJ 38.46 39.21 38.16 38.54 27349 20090901 STJ 38.4 38.8 37.59 37.97 34044 20090902 STJ 37.8 38.31 37.52 38.1 28950 20090903 STJ 37.975 38.42 37.94 38.31 21625 20090904 STJ 38.27 39.53 37.94 39.4 21067 20090909 STJ 38.4 39.45 38.36 38.99 26839 20090910 STJ 38.86 39.51 37.82 39.43 25304 20090911 STJ 39.39 39.55 38.91 39.01 33148 20090914 STJ 39.03 39.09 38.59 39.04 25634 20090915 STJ 39 39 37.96 38.34 42407 20090916 STJ 38.37 38.37 37.37 38 44102 20090917 STJ 37.87 38.34 37.66 38.29 46786 20090918 STJ 38.35 38.6 38.23 38.45 30324 20090921 STJ 38.29 39.45 38.11 39.23 34523 20090922 STJ 39.38 39.7 39.16 39.23 50520 20090923 STJ 39.14 39.46 38.69 39.04 34231 20090924 STJ 39.02 39.46 38.82 39.29 41933 20090925 STJ 39.14 39.41 38.75 39.22 19714 20090928 STJ 39.32 40.04 39.26 39.65 34682 20090929 STJ 39.78 39.95 39.49 39.74 16493 20090930 STJ 38.86 39.19 38.13 39.01 45154 20091001 STJ 38.97 38.97 38.11 38.39 34116 20091002 STJ 38.08 38.39 37.8 37.98 30309 20091005 STJ 38.01 38.37 37.59 38.24 13738 20091006 STJ 32.7 34.46 32.5 33.4 518107 20091007 STJ 33.71 33.96 32.925 33.01 128153 20091008 STJ 33.34 33.42 32.65 32.79 80710 20091009 STJ 32.98 34.31 32.68 34.1 86538 20091012 STJ 34.3 34.4 33.22 33.44 49680 20091013 STJ 33.53 33.65 33.18 33.27 40281 20091014 STJ 33.5 33.5 32.71 32.99 75429 20091015 STJ 32.88 33.62 32.88 33.6 41144 20091016 STJ 33.49 33.8705 33.26 33.83 35628 20091019 STJ 33.85 34.39 33.435 34.28 52408 20091020 STJ 33.54 33.66 31.66 33.16 161557 20091021 STJ 33.23 34.86 33.15 34.11 138110 20091022 STJ 33.98 34.64 33.71 34.43 78587 20091023 STJ 34.58 34.82 34.15 34.4 60890 20091026 STJ 34.48 34.97 34.3 34.75 67728 20091027 STJ 34.73 35.225 34.34 35.16 64881 20091028 STJ 34.91 35.03 34.33 34.33 55601 20091105 STJ 34.65 34.89 34.42 34.8 24814 20091106 STJ 34.57 35.09 34.48 34.79 24055 20091109 STJ 35.02 35.28 34.52 35.23 30265 20091110 STJ 35.1 35.64 34.87 35.39 29548 20091111 STJ 35.45 35.62 35.07 35.49 24028 20091112 STJ 35.24 35.48 34.34 34.74 43393 20091113 STJ 34.72 35.04 34.1 34.18 46321 20091116 STJ 34.33 34.83 34.3 34.46 33548 20091117 STJ 34.37 34.71 34.37 34.67 23118 20091118 STJ 34.72 35.27 34.66 35.06 27166 20091119 STJ 34.94 34.94 34.19 34.5 30326 20091120 STJ 34.38 34.66 34.25 34.32 36137 20091123 STJ 34.32 35.11 34.32 35.01 36417 20091124 STJ 35.1 36.84 35.01 36.42 81443 20091125 STJ 36.36 36.98 36.01 36.79 34595 20091127 STJ 36.17 36.61 - ---- - -QLGC 20.02 20.58 20.01 20.56 17157 20100324 QLGC 20.35 20.52 20.22 20.32 14140 20100325 QLGC 20.65 20.68 20.17 20.18 12204 20100326 QLGC 20.26 20.35 20.02 20.16 14125 20100329 QLGC 20.25 20.45 19.97 20.07 18847 20100330 QLGC 20 20.46 19.92 20.39 16918 20100331 QLGC 20.35 20.52 20.26 20.3 14058 20100401 QLGC 20.49 20.74 19.89 20.1 26535 20100405 QLGC 20.23 20.77 20.11 20.72 32973 20100406 QLGC 20.55 20.82 20.375 20.72 31325 20100407 QLGC 20.75 20.95 20.56 20.81 18819 20100408 QLGC 20.13 20.27 19.855 20.15 44993 20100409 QLGC 20.27 20.44 19.98 20.39 48266 20100412 QLGC 20.42 20.7 20.39 20.65 23701 20100413 QLGC 20.5 20.86 20.44 20.77 18468 20100414 QLGC 20.83 21.265 20.7225 21.2 25625 20100415 QLGC 21.11 21.41 21.03 21.31 11927 20100416 QLGC 21.12 21.305 20.7 21.09 29109 20100419 QLGC 21.06 21.15 20.5 20.94 29637 20100420 QLGC 21 21.34 20.845 21.19 16383 20100421 QLGC 21.12 21.55 21.12 21.52 15514 20100422 QLGC 21.29 22.18 21.13 22.13 22224 20100423 QLGC 22.09 22.34 21.87 22.31 18085 20100426 QLGC 22.31 22.4 22.03 22.07 19795 20100427 QLGC 21.72 21.89 21.18 21.22 43582 20100428 QLGC 21.25 21.45 20.9 21.02 39179 20100429 QLGC 21.14 21.65 21.06 21.58 29711 20100430 QLGC 20.3 20.55 19.21 19.37 86975 20100503 QLGC 19.51 20.1 19.49 19.93 31820 20100504 QLGC 19.61 19.66 19.05 19.5 35630 20100505 QLGC 19.46 19.93 19.22 19.6 35276 20100506 QLGC 19.61 19.9 17.62 18.99 33639 20100507 QLGC 18.92 19.17 18.22 18.5 40455 20100510 QLGC 19.43 19.87 19.08 19.56 30714 20100511 QLGC 19.23 19.415 19.02 19.13 36443 20100512 QLGC 19.27 19.81 19.25 19.74 21755 20100513 QLGC 19.85 19.93 19.34 19.35 22912 20100514 QLGC 19.31 19.31 18.64 18.96 33431 20100517 QLGC 19.14 19.27 18.52 18.99 34762 20100518 QLGC 19.23 19.24 18.56 18.57 34912 20100519 QLGC 18.57 18.83 18.17 18.5 30911 20100520 QLGC 17.96 18.32 17.71 17.85 31388 20100521 QLGC 17.51 18.15 17.49 18.01 36094 20100524 QLGC 17.79 18.26 17.76 17.94 24097 20100525 QLGC 17.55 17.86 17.17 17.86 25245 20100526 QLGC 17.92 18.215 17.53 17.57 36202 20100527 QLGC 17.92 18.435 17.85 18.35 30995 20100528 QLGC 18.3 18.47 18.045 18.12 29139 20100601 QLGC 18.07 18.36 17.91 17.91 28250 20100602 QLGC 17.86 18.33 17.855 18.31 18379 20100603 QLGC 18.24 18.48 18.11 18.4 23481 20100604 QLGC 17.79 18.3 17.44 17.55 28793 20100607 QLGC 17.55 17.75 16.92 16.97 30889 20100608 QLGC 16.99 17.01 16.44 16.7 42786 20100610 QLGC 16.66 16.84 16.42 16.82 39996 20100611 QLGC 16.66 17.19 16.39 17.03 44010 20100614 QLGC 17.13 17.41 16.98 17.04 30183 20100615 QLGC 17.23 17.76 17.14 17.76 29148 20100616 QLGC 17.7 17.87 17.52 17.75 24879 20100617 QLGC 17.84 18.06 17.55 17.92 24143 20100618 QLGC 17.99 18.2625 17.96 18.08 27537 20100621 QLGC 18.3 18.45 17.87 17.95 22196 20100622 QLGC 18.03 18.315 17.54 17.74 19710 20100623 QLGC 17.89 18.21 17.7 17.96 24302 20100624 QLGC 18 18 17.37 17.47 22383 20100625 QLGC 17.59 17.74 17.19 17.59 21834 20100628 QLGC 17.59 17.84 17.32 17.62 13054 20100630 QLGC 16.88 17.14 16.6 16.62 20230 20100701 QLGC 16.56 16.935 16.18 16.91 25953 20100702 QLGC 16.87 17.02 16.62 16.8 16869 20100706 QLGC 17.15 17.32 16.76 16.94 24613 20100707 QLGC 17.13 17.76 16.93 17.7125 21566 20100708 QLGC 17.78 18.13 17.71 18.03 17565 20100709 QLGC 18.04 18.17 17.88 18.13 14464 20100712 QLGC 17.99 18.44 17.97 18.22 12050 20100713 QLGC 18.44 18.68 18.215 18.58 12116 20100714 QLGC 18.67 19.075 18.59 18.74 18074 20100715 QLGC 18.7 18.89 18.43 18.83 14157 20100716 QLGC 18.78 18.78 18.19 18.29 17734 20100719 QLGC 18.29 18.47 18.09 18.4 13397 20100720 QLGC 18.16 18.53 17.82 18.5 15938 20100721 QLGC 18.61 18.82 18.37 18.6 33454 20100722 QLGC 18.56 19.18 18.56 18.85 44393 20100723 QLGC 16.59 16.77 15.59 15.76 146116 20100726 QLGC 15.77 16.02 15.51 15.98 60189 20100727 QLGC 16.085 16.37 15.81 16.26 52369 20100728 QLGC 16.26 16.34 15.95 16.04 31670 20100729 QLGC 16.29 16.29 15.72 15.93 25731 20100730 QLGC 15.77 16.045 15.67 15.92 26059 20100802 QLGC 16.19 16.37 16.08 16.29 21455 20100803 QLGC 16.22 16.25 15.8 15.85 39402 20100804 QLGC 16 16 - ---- - -26.38 26.66 6929 20090826 FII 26.46 26.69 26.39 26.52 5968 20090827 FII 26.59 26.71 26.09 26.49 6150 20090828 FII 26.57 26.74 26.12 26.43 3582 20090831 FII 26.12 26.28 25.73 26.25 5211 20090901 FII 26.15 26.29 25.34 25.46 10755 20090902 FII 25.3 25.6 25.08 25.43 8253 20090903 FII 25.63 25.7 25.05 25.34 19483 20090904 FII 25.44 25.48 24.88 25.37 9646 20090909 FII 26.09 26.68 25.93 26.65 7111 20090910 FII 26.54 26.63 25.95 26.31 9684 20090911 FII 26.285 26.32 25.6 25.66 9477 20090914 FII 25.47 26.33 25.41 26.31 8687 20090915 FII 26.24 26.25 25.89 26.08 6814 20090916 FII 26.06 27.02 25.99 26.89 12069 20090917 FII 26.88 27.31 26.83 26.94 7658 20090918 FII 27.2 27.22 26.78 26.98 9746 20090921 FII 26.82 26.9 26.61 26.62 5705 20090922 FII 26.89 27.27 26.6 27.19 8415 20090923 FII 27.22 27.5 26.66 26.66 8415 20090924 FII 26.52 26.55 25.48 25.65 14082 20090925 FII 25.69 25.69 24.97 25.29 10248 20090928 FII 25.4 25.98 25.27 25.97 6149 20090929 FII 26 26.41 25.95 26.24 7255 20090930 FII 26.27 26.62 26.09 26.37 7536 20091001 FII 26.21 26.42 25.13 25.15 15793 20091002 FII 24.92 25.06 24.76 24.99 12058 20091005 FII 25.16 26.05 24.93 26.04 12625 20091006 FII 26.3 26.3 25.5 25.88 12591 20091007 FII 25.66 25.95 25.61 25.87 11117 20091008 FII 26.09 26.28 25.87 25.97 6501 20091009 FII 25.88 26.14 25.81 26.03 5096 20091012 FII 26.16 26.32 25.7 25.94 4732 20091013 FII 25.92 25.96 25.63 25.74 4680 20091014 FII 26.22 26.75 26.03 26.62 10679 20091015 FII 26.55 26.69 26.44 26.62 7732 20091016 FII 26.14 26.25 25.82 25.97 8338 20091019 FII 26.01 26.34 25.81 26.19 5761 20091020 FII 26.17 26.42 25.92 26.22 9313 20091021 FII 26.1 26.64 25.75 25.83 10824 20091022 FII 25.83 26.99 25.66 26.86 15082 20091023 FII 27.29 27.91 26.945 27.39 20090 20091026 FII 27.37 27.99 27.37 27.52 18303 20091027 FII 27.5 28.1 27.4 27.53 15938 20091028 FII 27.57 27.75 26.7 26.73 15378 20091105 FII 26.49 26.61 26.19 26.58 8903 20091106 FII 26.39 26.7 26.2 26.62 7582 20091109 FII 26.8 27.29 26.66 27.27 6560 20091110 FII 27.18 27.38 26.97 27.22 6515 20091111 FII 27.45 27.7 27.37 27.55 6355 20091112 FII 27.53 27.72 27.25 27.26 7942 20091113 FII 27.26 27.55 27.06 27.54 6741 20091116 FII 27.79 28.05 27.73 27.91 11054 20091117 FII 27.91 27.96 27.6 27.69 12037 20091118 FII 27.6 27.67 27.13 27.35 12883 20091119 FII 27.2 27.28 26.72 26.94 9063 20091120 FII 26.83 26.85 26.59 26.64 10392 20091123 FII 26.98 26.98 25.97 26.1 20430 20091124 FII 26.25 26.81 25.86 26.05 17889 20091125 FII 26.23 26.29 26.02 26.1 9168 20091127 FII 25.5 25.83 25.41 25.6 7487 20091130 FII 25.66 25.87 25.51 25.78 12219 20091201 FII 25.99 26.18 25.8 26 9614 20091202 FII 26 26.13 25.68 25.78 12213 20091203 FII 25.92 26.11 25.67 25.73 11236 20091204 FII 26.11 26.15 25.355 25.78 11952 20091207 FII 25.67 25.8 24.98 25.01 19250 20091208 FII 24.92 25.11 24.81 24.96 9299 20091209 FII 24.94 25.4 24.86 25.28 8199 20091210 FII 25.43 25.56 25.31 25.33 5959 20091211 FII 25.4 25.45 25.15 25.36 7733 20091214 FII 25.42 25.44 25.05 25.22 8885 20091215 FII 25.14 25.14 24.87 25 13821 20091216 FII 25.14 25.73 25.04 25.7 11484 20091217 FII 25.51 25.88 25.49 25.76 15670 20091218 FII 25.98 26.47 25.98 26.47 20840 20091221 FII 26.58 27.11 26.41 27.05 12565 20091222 FII 26.97 27.69 26.96 27.69 14920 20091223 FII 27.69 28.3 27.68 27.96 13819 20091224 FII 27.99 28.31 27.81 28.02 2815 20091228 FII 28.02 28.19 27.87 27.94 4326 20091229 FII 27.99 28.06 27.72 27.79 7549 20091230 FII 27.68 27.87 27.56 27.87 5014 20091231 FII 27.84 28 27.5 27.5 7737 20100104 FII 27.76 28.03 27.44 28 13887 20100105 FII 27.97 28.14 27.67 28.01 10957 20100106 FII 27.94 28.03 27.7 27.81 6638 20100107 FII 27.72 27.93 27.49 27.58 10383 20100108 FII 27.67 27.67 27.32 27.57 8779 20100111 FII 27.76 27.9002 27.6 27.88 8162 20100112 FII 27.7 27.98 27.59 27.68 6493 20100113 FII 27.8 27.83 27.59 27.73 4771 20100114 FII 27.71 27.71 27.3002 27.5 5040 20100115 FII 27.43 27.55 27.22 27.3 7268 20100119 FII 27.4 27.76 27.25 27.75 6077 20100120 FII 27.44 27.62 27.21 27.48 6555 20100121 - ---- - -20091221 IP 26.81 27.45 26.77 27.01 35898 20091222 IP 27.18 27.49 27 27.4 25862 20091223 IP 27.41 27.79 27.26 27.66 20397 20091224 IP 27.69 27.75 27.32 27.45 8359 20091228 IP 27.49 27.68 27.03 27.28 16943 20091229 IP 27.36 27.67 27.04 27.22 15926 20091230 IP 27.08 27.33 26.94 27.23 27116 20091231 IP 27.19 27.41 26.78 26.78 14847 20100104 IP 27.19 27.45 27.04 27.18 39791 20100105 IP 27.17 28.45 27.01 28.14 51770 20100106 IP 27.65 28.61 27.63 27.82 57838 20100107 IP 27.67 27.7 26.67 26.76 69770 20100108 IP 26.76 27.03 26.23 26.93 45309 20100111 IP 27.24 27.24 26.36 26.61 44015 20100112 IP 26.28 27.52 26.28 26.68 80098 20100113 IP 26.75 27.02 26.38 26.62 36673 20100114 IP 26.58 26.6 26.09 26.23 32559 20100115 IP 26.19 26.56 25.7 26.08 48452 20100119 IP 26.12 26.99 25.92 26.96 45631 20100120 IP 26.62 26.79 25.95 26.28 35593 20100121 IP 26.42 26.48 24.44 24.45 75303 20100122 IP 24.54 25.02 23.8 24.43 85908 20100125 IP 25.08 25.42 24.45 24.5 48904 20100126 IP 24.24 24.9 24.2 24.47 43683 20100127 IP 24.3 24.35 23.13 23.88 76132 20100128 IP 24.03 24.03 22.63 23.07 67499 20100129 IP 23.27 23.53 22.82 22.91 42216 20100201 IP 23.24 23.93 23 23.9 55542 20100202 IP 23.94 24.32 23.65 24.02 64130 20100203 IP 22.79 23.24 22.12 22.67 152623 20100204 IP 22.77 22.77 21.85 22.15 97667 20100205 IP 22.15 22.73 21.66 22.67 118224 20100208 IP 22.6 23.05 22.125 22.51 74659 20100209 IP 22.95 23.3 22.5 22.92 67544 20100210 IP 22.91 23.01 22.05 22.41 59668 20100211 IP 22.28 22.66 22.17 22.37 68670 20100212 IP 22.19 22.6 21.68 22.57 66503 20100216 IP 22.77 24.15 22.77 24.1 102362 20100217 IP 24.05 24.47 23.55 23.71 59807 20100218 IP 23.56 24.45 23.51 24.23 47382 20100219 IP 24.03 24.59 23.85 24.25 45587 20100222 IP 24.44 24.44 23.32 23.99 53809 20100223 IP 24.02 24.88 23.87 24.01 70059 20100224 IP 24.01 24.31 23.77 23.9 39954 20100225 IP 23.5 24.03 23.29 23.89 52157 20100226 IP 23.86 23.97 23.12 23.17 66944 20100301 IP 23.4 24.21 23.3 24.18 59525 20100302 IP 24.38 25.16 23.5126 25.03 86252 20100303 IP 25.11 25.6 24.91 25.2 62322 20100304 IP 25.33 25.5 24.58 24.98 44022 20100305 IP 25.19 25.52 25.07 25.35 60176 20100308 IP 25.35 25.42 24.96 25.25 44131 20100309 IP 25.15 25.44 24.92 25.09 58301 20100310 IP 25.07 25.51 24.88 25.11 48369 20100311 IP 25 25.22 24.79 25.2 59009 20100312 IP 25.45 25.71 25.25 25.34 61449 20100315 IP 25.22 25.2887 24.74 24.91 48087 20100316 IP 25.11 25.5 25.03 25.38 79486 20100317 IP 25.48 27.29 25.48 27.02 156381 20100318 IP 26.86 26.99 26.14 26.42 69875 20100319 IP 26.7 26.73 25.74 25.82 68893 20100322 IP 25.81 26.16 25.55 26.05 80615 20100323 IP 26.05 26.2 25.8 26.16 89003 20100324 IP 26.1 26.47 25.82 26.21 91675 20100325 IP 26.5 26.58 25.21 25.21 78592 20100326 IP 25.38 25.625 24.95 24.99 91005 20100329 IP 25.24 25.48 25.06 25.15 65090 20100330 IP 25.24 25.52 24.9 25.26 42112 20100331 IP 25.11 25.12 24.53 24.61 56030 20100401 IP 24.83 25.29 24.83 25.24 62528 20100405 IP 25.37 25.57 25.2 25.5 58887 20100406 IP 25.28 25.93 25.2 25.91 78716 20100407 IP 26.05 27.33 26.05 27.01 142374 20100408 IP 26.8 27.49 26.48 27.42 78594 20100409 IP 27.42 27.695 27.035 27.47 52407 20100412 IP 27.62 27.62 26.94 27.14 60671 20100413 IP 27.07 27.31 26.8601 27.23 58521 20100414 IP 27.43 28.15 27.43 28.1 53915 20100415 IP 27.93 28.47 27.82 28.1 56791 20100416 IP 27.94 28.58 27.45 27.85 83311 20100419 IP 27.65 27.83 26.912 27.44 58609 20100420 IP 27.71 28.06 27.23 27.42 74143 20100421 IP 27.47 28.43 27.47 28.17 76808 20100422 IP 27.84 28.42 27.57 28.37 41674 20100423 IP 28.41 28.8 28.16 28.63 45850 20100426 IP 28.67 29.25 28.12 28.41 58953 20100427 IP 28.31 28.31 26.905 27.05 64589 20100428 IP 27.17 27.66 26.86 27.18 59656 20100429 IP 27.99 29.14 27.78 28 85452 20100430 IP 28.27 28.45 26.73 26.74 74474 20100503 IP 26.95 27.1301 25.99 26.64 90331 20100504 IP 26.19 26.19 24.81 25.01 111810 20100505 IP 24.6 25.45 24.3 24.76 79523 20100506 IP 24.55 25.16 20.5 23.34 152968 20100507 IP 22.23 23.8 21.53 23.16 151037 20100510 IP 25.01 25.45 24.22 24.79 80144 - ---- - -23.36 23.895 23.07 23.64 19368 20100629 CFN 23.35 23.4 22.76 22.85 16452 20100630 CFN 22.78 23 22.66 22.7 16949 20100701 CFN 22.65 22.65 21.93 22.41 22401 20100702 CFN 22.39 22.76 22.2075 22.42 15566 20100706 CFN 22.6 23.29 22.46 22.72 20290 20100707 CFN 23.08 23.15 22.42 22.76 26014 20100708 CFN 22.82 23.1 22.55 22.75 26439 20100709 CFN 22.75 22.75 22.39 22.61 27368 20100712 CFN 22.53 22.62 22.29 22.48 19209 20100713 CFN 22.57 22.9488 22.34 22.86 31311 20100714 CFN 22.8 22.8 22.28 22.56 21951 20100715 CFN 22.5 22.58 22.13 22.42 17123 20100716 CFN 22.26 22.4 21.44 21.55 28220 20100719 CFN 21.59 21.9 21.53 21.83 13903 20100720 CFN 21.67 21.79 21.36 21.66 17946 20100721 CFN 21.68 21.83 20.63 20.68 27314 20100722 CFN 20.89 21.56 20.84 21.19 19021 20100723 CFN 21.09 21.56 21.02 21.56 12887 20100726 CFN 21.48 21.86 21.38 21.85 21351 20100727 CFN 21.92 22.03 21.39 21.52 26421 20100728 CFN 21.45 21.6 21.19 21.31 18182 20100729 CFN 21.37 21.55 20.9 21.1 13138 20100730 CFN 20.94 21.445 20.86 21.07 12556 20100802 CFN 21.35 21.82 21.35 21.43 18314 20100803 CFN 21.48 21.48 21.07 21.14 10389 20100804 CFN 21.17 21.48 21.17 21.45 17342 20100805 CFN 21.32 21.56 21.15 21.49 9523 20100806 CFN 21.32 21.62 21.23 21.49 12990 20100809 CFN 21.63 21.93 21.59 21.72 13733 20100810 CFN 21.58 21.61 20.97 21.4 24851 20100811 CFN 21.91 23.87 21.5 23.26 61782 20100812 CFN 23.04 23.04 22.43 22.75 34432 20100813 CFN 22.64 23.15 22.52 22.85 25298 20100816 CFN 22.73 22.86 22.45 22.59 10549 20100817 CFN 22.79 22.81 22.53 22.53 14979 20100819 CFN 22.37 22.63 21.99 22 16279 20100820 CFN 21.85 22.86 21.53 22.81 24163 20090821 CHK 23.4 23.94 23.29 23.79 106618 20090824 CHK 24 24.36 23.84 23.94 138358 20090825 CHK 24.09 24.23 23.31 23.35 99893 20090826 CHK 23.07 23.45 22.79 23.31 82364 20090827 CHK 23.17 23.22 22.5 23.2 103404 20090828 CHK 23.45 23.6 23.04 23.59 118563 20090831 CHK 23.18 23.25 22.67 22.84 120627 20090901 CHK 22.68 23.42 22.48 22.5 139079 20090902 CHK 22.38 22.7 22.13 22.13 113355 20090903 CHK 22.36 22.49 21.45 21.58 178845 20090904 CHK 21.62 22.27 21.6 22.2 98630 20090909 CHK 23.35 24.15 23.1 23.65 143061 20090910 CHK 23.71 25.41 23.67 25.25 221379 20090911 CHK 25.87 27.1 25.57 26.12 366022 20090914 CHK 25.6 27.16 25.37 27.09 202867 20090915 CHK 27.75 28.5 27.62 28.31 244841 20090916 CHK 28.81 28.99 28.02 28.92 206681 20090917 CHK 28.69 29.2 27.52 27.97 214803 20090918 CHK 28.19 28.35 27.27 27.85 283390 20090921 CHK 27.34 28.19 26.5666 28.11 142238 20090922 CHK 28.57 29.49 28.52 29.11 138463 20090923 CHK 29.16 29.28 28.22 28.3 151353 20090924 CHK 28.35 28.46 27.03 27.82 134923 20090925 CHK 27.61 28.12 27.3 27.53 114799 20090928 CHK 27.55 28.3 27.35 28.17 94562 20090929 CHK 27.92 28.84 27.76 28.59 123885 20090930 CHK 28.8 28.94 27.82 28.4 151594 20091001 CHK 28.31 28.4 26.43 26.5 169100 20091002 CHK 25.74 26.81 25.28 26.7 152501 20091005 CHK 26.94 27.63 26.81 27.5 118176 20091006 CHK 27.48 27.97 27.13 27.74 150919 20091007 CHK 27.65 28.05 27.08 27.59 117706 20091008 CHK 27.97 28.36 27.48 28.28 245382 20091009 CHK 28.18 28.8 28.04 28.66 95692 20091012 CHK 28.77 29.24 28.77 29.01 96061 20091013 CHK 29.25 29.75 28.59 29.46 161349 20091014 CHK 29.98 30 28.29 28.49 259444 20091015 CHK 28.44 29.19 28.32 28.93 151825 20091016 CHK 28.66 29.04 28.51 28.67 138658 20091019 CHK 28.88 29.05 28.62 28.97 80125 20091020 CHK 29.13 29.25 28 28.85 114258 20091021 CHK 28.5 29.68 28.4 28.83 143480 20091022 CHK 28.35 28.6 27.41 27.94 202661 20091023 CHK 28.22 28.33 26.55 26.73 133640 20091026 CHK 26.88 27.59 25.71 25.73 150438 20091027 CHK 25.87 26.86 25.695 26.34 239658 20091028 CHK 26.13 26.13 24.71 24.77 170707 20091105 CHK 24.51 24.94 24.01 24.82 112358 20091106 CHK 24.42 24.95 24.04 24.22 126812 20091109 CHK 24.82 25.35 24.73 25.26 114620 20091110 CHK 25.15 25.42 24.81 25.34 99365 20091111 CHK 25.65 25.81 25.02 25.18 128210 20091112 CHK 25.17 25.69 24.6 24.71 166518 20091113 CHK 24.87 25.2 24.57 25.03 132923 20091116 CHK 25.27 25.61 24.96 25.14 154597 20091117 CHK - ---- - -17.55 17.95 17.37 17.58 57694 20100607 SAI 17.65 17.75 17.4 17.49 35298 20100608 SAI 17.53 17.53 17.28 17.39 44461 20100609 SAI 17.41 17.59 17.34 17.4 35663 20100610 SAI 17.5 17.85 17.5 17.69 45181 20100611 SAI 17.53 17.59 17.34 17.52 46115 20100614 SAI 17.7 17.77 17.51 17.53 54785 20100615 SAI 17.53 17.78 17.53 17.72 36795 20100616 SAI 17.71 18.02 17.65 17.95 42567 20100617 SAI 18 18.09 17.89 18.09 28826 20100618 SAI 18.11 18.2 17.95 17.99 47392 20100621 SAI 18.06 18.18 17.74 17.77 32579 20100622 SAI 17.69 17.78 17.47 17.48 28411 20100623 SAI 17.45 17.48 17.23 17.27 40351 20100624 SAI 17.24 17.43 17.13 17.16 35363 20100625 SAI 17.18 17.3 17.01 17.17 94368 20100628 SAI 17.13 17.27 17.03 17.09 36008 20100629 SAI 17 17.07 16.75 16.82 55804 20100630 SAI 16.9 17.05 16.72 16.74 40656 20100701 SAI 16.7 16.71 16.42 16.55 37781 20100702 SAI 16.59 16.6 16.38 16.43 18416 20100706 SAI 16.66 16.66 16.37 16.5 30794 20100707 SAI 16.44 16.69 16.43 16.68 20026 20100708 SAI 16.72 17.015 16.69 16.83 19202 20100709 SAI 16.81 16.88 16.7 16.85 14679 20100712 SAI 16.82 16.95 16.74 16.89 11999 20100713 SAI 16.99 16.99 16.81 16.92 18321 20100714 SAI 16.78 17.15 16.72 17.05 24410 20100715 SAI 16.99 17.04 16.76 16.9 18710 20100716 SAI 16.8 16.86 16.46 16.46 25825 20100719 SAI 16.41 16.64 16.38 16.54 27075 20100720 SAI 16.46 16.71 16.38 16.69 13313 20100721 SAI 16.72 16.76 16.44 16.47 16321 20100722 SAI 16.57 16.89 16.57 16.83 19505 20100723 SAI 16.78 17.01 16.74 16.98 14067 20100726 SAI 16.97 17 16.86 16.96 13848 20100727 SAI 16.96 17.01 16.79 16.94 16037 20100728 SAI 16.87 16.995 16.78 16.88 17620 20100729 SAI 16.94 16.98 16.62 16.72 15765 20100730 SAI 16.63 16.71 16.574 16.63 16196 20100802 SAI 16.73 16.97 16.6406 16.96 26908 20100803 SAI 16.95 17.09 16.86 17.02 29072 20100804 SAI 17.03 17.1 16.96 17.02 18381 20100805 SAI 16.99 17.2 16.9 17.16 15596 20100806 SAI 17.07 17.14 16.86 16.99 14040 20100809 SAI 17.01 17.06 16.8225 16.95 14942 20100810 SAI 16.81 16.91 16.5 16.59 32295 20100811 SAI 16.48 16.48 15.88 15.93 37773 20100812 SAI 15.64 15.89 15.61 15.87 28716 20100813 SAI 15.87 15.94 15.76 15.78 22608 20100816 SAI 15.71 15.81 15.53 15.54 15625 20100817 SAI 15.55 15.83 15.55 15.77 18613 20100819 SAI 15.6 15.61 15.25 15.52 27961 20100820 SAI 15.43 15.57 15.37 15.55 17602 20090821 SBUX 19.4 19.79 19.24 19.71 94353 20090824 SBUX 19.74 19.85 19.11 19.24 109927 20090825 SBUX 19.24 19.74 19.21 19.5 99323 20090826 SBUX 19.46 19.68 19.21 19.35 83908 20090827 SBUX 19.33 19.56 18.91 19.44 80924 20090828 SBUX 19.64 19.7 19.1575 19.33 66481 20090831 SBUX 19.15 19.28 18.85 18.99 105916 20090901 SBUX 18.94 19.35 18.42 18.56 146692 20090902 SBUX 18.42 18.75 18.38 18.56 85500 20090903 SBUX 18.58 18.69 18.21 18.69 113135 20090904 SBUX 18.72 19.15 18.46 19.02 78565 20090909 SBUX 19.21 20.21 19.13 20.09 206080 20090910 SBUX 20.1 20.24 19.67 19.97 163752 20090911 SBUX 19.93 20.02 19.66 19.89 96381 20090914 SBUX 19.66 20.19 19.58 20.08 92154 20090915 SBUX 20.02 20.16 19.72 19.79 107599 20090916 SBUX 19.84 19.8505 19.55 19.85 99970 20090917 SBUX 19.82 20.48 19.74 20.08 97143 20090918 SBUX 20.5 20.94 20.34 20.76 144985 20090921 SBUX 20.63 20.88 20.34 20.67 90899 20090922 SBUX 20.67 20.77 20.38 20.47 71516 20090923 SBUX 20.39 20.4599 19.66 19.69 118270 20090924 SBUX 19.77 19.92 19.01 19.17 164678 20090925 SBUX 19.21 20.11 19.02 19.83 179400 20090928 SBUX 19.91 20.77 19.88 20.62 129241 20090929 SBUX 20.63 20.76 20.17 20.38 93079 20090930 SBUX 20.36 20.73 19.72 20.65 141584 20091001 SBUX 20.55 20.6 19.8 19.97 118015 20091002 SBUX 19.74 20.0701 19.59 19.74 85075 20091005 SBUX 19.76 20.14 19.6 20.06 72789 20091006 SBUX 20.01 20.73 19.95 20.53 108923 20091007 SBUX 20.44 20.6 20.18 20.4 69970 20091008 SBUX 20.46 20.99 20.37 20.47 104376 20091009 SBUX 20.33 20.62 20.1 20.24 88916 20091012 SBUX 20.15 20.54 20.08 20.36 100194 20091013 SBUX 20.42 20.43 20.03 20.19 67601 20091014 SBUX 20.39 20.72 20.32 20.54 74390 20091015 SBUX 20.33 20.725 20.29 20.72 101432 20091016 SBUX 20.64 - ---- - -AEE 25.7 25.78 25.12 25.2 11525 20091026 AEE 25.27 25.59 24.88 25.01 26321 20091027 AEE 25.02 25.41 25 25.03 16176 20091028 AEE 24.97 25.23 24.72 24.99 19218 20091105 AEE 24.28 24.77 24.24 24.75 14314 20091106 AEE 24.68 24.9 24.54 24.68 13450 20091109 AEE 24.86 25.39 24.76 25.38 16218 20091110 AEE 25.31 25.58 25.31 25.53 18363 20091111 AEE 25.66 25.73 25.46 25.63 15535 20091112 AEE 25.54 25.65 25.29 25.4 13742 20091113 AEE 25.41 25.83 25.41 25.72 12993 20091116 AEE 25.76 25.99 25.66 25.79 20642 20091117 AEE 25.78 26.02 25.76 25.89 10856 20091118 AEE 25.85 25.94 25.7 25.88 10998 20091119 AEE 25.76 25.8 25.24 25.35 18888 20091120 AEE 25.27 25.36 25.1 25.28 21149 20091123 AEE 25.35 25.72 25.35 25.6 12373 20091124 AEE 25.68 25.77 25.4 25.77 15460 20091125 AEE 25.82 26.06 25.71 26 14560 20091127 AEE 25.59 25.78 25.3685 25.58 7625 20091130 AEE 25.54 26 25.47 25.99 24024 20091201 AEE 26.14 26.59 26.05 26.58 24827 20091202 AEE 26.63 26.97 26.51 26.89 24685 20091203 AEE 26.98 27.38 26.9 27.09 17479 20091204 AEE 27.35 27.64 26.75 27.01 37033 20091207 AEE 26.7 27.05 26.67 26.94 32543 20091208 AEE 26.93 26.94 26.63 26.72 18245 20091209 AEE 26.72 26.84 26.57 26.78 11218 20091210 AEE 26.88 27.22 26.8 26.98 14770 20091211 AEE 26.98 27.86 26.932 27.82 21946 20091214 AEE 27.88 28.37 27.88 28.16 17835 20091215 AEE 28.03 28.24 27.92 28.1 12638 20091216 AEE 28.13 28.2 27.69 27.75 17922 20091217 AEE 27.65 27.88 27.46 27.76 14179 20091218 AEE 27.85 28.045 27.54 28 18695 20091221 AEE 28.04 28.47 28.03 28.12 12074 20091222 AEE 28.2 28.3 27.92 28 12640 20091223 AEE 28.04 28.25 27.99 28.22 9112 20091224 AEE 28.19 28.54 28.19 28.53 3107 20091228 AEE 28.52 28.67 28.43 28.59 8059 20091229 AEE 28.55 28.63 28.45 28.45 6431 20091230 AEE 28.32 28.48 28.21 28.41 7453 20091231 AEE 28.56 28.64 27.95 27.95 8125 20100104 AEE 28.1 28.27 27.69 27.76 12992 20100105 AEE 27.76 27.84 27.41 27.65 14221 20100106 AEE 27.61 27.89 27.35 27.46 18802 20100107 AEE 27.47 27.47 27.05 27.2 9368 20100108 AEE 27.22 27.22 26.83 27.01 9540 20100111 AEE 27.05 27.28 27.05 27.23 9978 20100112 AEE 27.15 27.455 27.09 27.2 10218 20100113 AEE 27.2 27.49 27.14 27.38 12408 20100114 AEE 27.26 27.5 27.25 27.48 7630 20100115 AEE 27.41 27.48 26.92 27.34 17760 20100119 AEE 27.37 27.74 27.27 27.69 12729 20100120 AEE 27.5 27.54 27.03 27.17 16385 20100121 AEE 27.21 27.4 26.22 26.52 40651 20100122 AEE 26.58 26.58 25.75 25.78 25699 20100125 AEE 26.01 26.065 25.76 25.91 15819 20100126 AEE 25.86 26.08 25.73 25.98 15250 20100127 AEE 25.98 26.05 25.6 25.99 19436 20100128 AEE 25.88 26.03 25.5 25.73 18879 20100129 AEE 25.86 25.93 25.51 25.55 15829 20100201 AEE 25.59 25.75 25.32 25.49 17151 20100202 AEE 25.48 25.78 25.25 25.77 19811 20100203 AEE 25.32 25.65 25.29 25.61 21624 20100204 AEE 25.45 25.46 24.98 24.98 16528 20100205 AEE 25 25.03 24.45 24.86 28363 20100208 AEE 24.88 24.99 24.42 24.42 18577 20100209 AEE 24.62 24.99 24.51 24.63 19161 20100210 AEE 24.66 24.66 24.29 24.41 20904 20100211 AEE 24.41 24.71 24.14 24.63 26048 20100212 AEE 24.46 24.63 24.25 24.56 19867 20100216 AEE 24.76 25.15 24.71 25.09 14547 20100217 AEE 25.22 25.4 25.06 25.4 19574 20100218 AEE 25.47 26.25 25.47 25.64 31384 20100219 AEE 25.62 26.055 25.35 25.65 20659 20100222 AEE 25.8 25.82 25.36 25.41 13968 20100223 AEE 25.4 25.4699 25.17 25.29 14028 20100224 AEE 25.34 25.45 24.89 25.14 16401 20100225 AEE 24.91 25.07 24.66 25.07 18760 20100226 AEE 25.12 25.12 24.65 24.71 21390 20100301 AEE 24.82 25.14 24.82 25.04 13755 20100302 AEE 25.17 25.36 25.13 25.33 12530 20100303 AEE 25.34 25.53 25.28 25.43 15807 20100304 AEE 25.42 25.6 25.3 25.59 16039 20100305 AEE 25.74 25.94 25.6 25.94 20167 20100308 AEE 25.44 25.53 25.31 25.5 19572 20100309 AEE 25.44 25.61 25.37 25.57 13655 20100310 AEE 25.58 25.78 25.45 25.57 16012 20100311 AEE 25.56 25.76 25.36 25.76 12690 20100312 AEE 25.82 25.89 25.5 25.51 11751 20100315 AEE 25.49 25.5999 25.35 25.49 16995 20100316 AEE 25.49 25.58 25.4 25.5 14483 20100317 AEE 25.5 25.7 25.43 25.67 10146 20100318 AEE 25.69 26 - ---- - -24.85 291030 20091002 FIS 24.55 24.74 23.96 23.99 57072 20091005 FIS 24.07 24.37 23.89 23.91 55853 20091006 FIS 24.01 24.49 23.93 24.28 45289 20091007 FIS 24.23 24.48 23.93 24.13 37881 20091008 FIS 24.36 24.48 24.12 24.3 28166 20091009 FIS 24.21 24.41 24.055 24.35 23512 20091012 FIS 24.19 24.47 24.13 24.3 20012 20091013 FIS 24.21 24.37 23.99 24.14 26352 20091014 FIS 24.24 24.46 24.22 24.44 21448 20091015 FIS 24.28 24.56 24.22 24.53 20971 20091016 FIS 24.38 24.98 24.14 24.43 31087 20091019 FIS 24.46 24.82 24.44 24.6 24752 20091020 FIS 24.55 24.55 24.27 24.51 20685 20091021 FIS 24.38 25.12 24.33 24.83 50850 20091022 FIS 22.92 23.95 22.38 23.64 116624 20091023 FIS 23.79 23.79 22.69 22.82 35424 20091026 FIS 22.8 22.94 22.44 22.61 36035 20091027 FIS 22.63 22.76 22.47 22.58 33560 20091028 FIS 22.46 22.46 21.75 21.78 43643 20091105 FIS 22.12 22.55 21.95 22.55 27787 20091106 FIS 22.53 22.66 22.14 22.46 29781 20091109 FIS 22.5 22.95 22.39 22.94 26490 20091110 FIS 22.82 22.94 22.65 22.9 25483 20091111 FIS 23.03 23.07 22.7 22.94 21141 20091112 FIS 22.9 23 22.61 22.66 23388 20091113 FIS 22.59 22.8 22.38 22.59 20263 20091116 FIS 22.58 22.77 22.51 22.63 38179 20091117 FIS 22.65 22.81 22.35 22.58 28466 20091118 FIS 23.39 23.9 22.99 23.47 46192 20091119 FIS 23.27 23.5 22.91 23.11 35826 20091120 FIS 22.85 23 22.64 22.73 29178 20091123 FIS 23.06 23.065 22.74 22.97 27407 20091124 FIS 23.04 23.04 22.69 22.77 21316 20091125 FIS 23 23.2 22.9 22.98 46120 20091127 FIS 22.53 22.71 22.4 22.53 14833 20091130 FIS 22.46 22.65 22.34 22.6 25390 20091201 FIS 22.73 23.48 22.69 23.42 32213 20091202 FIS 23.23 23.59 23.2 23.32 22563 20091203 FIS 23.34 23.5 23.01 23.17 22167 20091204 FIS 23.38 23.6 23.03 23.46 25041 20091207 FIS 23.31 23.73 23.11 23.48 46789 20091208 FIS 23.37 23.42 23.05 23.17 34865 20091209 FIS 23.03 23.4 22.87 23.32 30689 20091210 FIS 23.45 23.74 23.37 23.67 25488 20091211 FIS 23.72 23.77 23.57 23.73 20987 20091214 FIS 23.77 23.96 23.7 23.96 22964 20091215 FIS 23.76 23.88 23.66 23.76 31986 20091216 FIS 23.83 23.895 23.38 23.52 29442 20091217 FIS 23.42 23.48 23.16 23.17 18009 20091218 FIS 23.47 24.05 23.31 23.53 27895 20091221 FIS 23.49 23.7 23.25 23.3 23012 20091222 FIS 23.35 23.65 23.32 23.59 14014 20091223 FIS 23.55 23.79 23.52 23.75 11607 20091224 FIS 23.79 24 23.75 23.98 4714 20091228 FIS 23.93 23.96 23.69 23.72 15667 20091229 FIS 23.75 23.94 23.63 23.63 8039 20091230 FIS 23.62 23.76 23.49 23.61 18191 20091231 FIS 23.7 23.7 23.44 23.44 9634 20100104 FIS 23.63 23.96 23.44 23.82 46236 20100105 FIS 23.99 24.88 23.93 24.84 48687 20100106 FIS 24.81 24.93 24.54 24.7 24811 20100107 FIS 24.69 24.69 24.41 24.56 33848 20100108 FIS 24 24.3 23.86 24.05 24599 20100111 FIS 24.2 24.25 23.74 23.93 30100 20100112 FIS 23.8 23.87 23.65 23.85 20386 20100113 FIS 23.53 24.345 23.53 24.25 34669 20100114 FIS 24.24 24.4 24.09 24.35 11709 20100115 FIS 24.34 24.4 23.9 23.99 20619 20100119 FIS 23.88 24.43 23.86 24.41 18183 20100120 FIS 24.21 24.45 23.92 24.25 21683 20100121 FIS 24.25 24.94 24.1 24.34 49646 20100122 FIS 24.23 24.48 23.95 23.96 38003 20100125 FIS 24.15 24.385 23.95 24.07 33978 20100126 FIS 24.02 24.24 23.95 24.01 21739 20100127 FIS 24.01 24.23 23.87 24.22 24548 20100128 FIS 24.21 24.22 23.63 23.75 38237 20100129 FIS 23.83 23.96 23.52 23.56 27140 20100201 FIS 23.85 23.85 23.48 23.76 23252 20100202 FIS 23.79 23.95 23.56 23.95 23251 20100203 FIS 23.83 24.01 23.62 23.99 25181 20100204 FIS 24.01 24.15 23.52 23.54 42529 20100205 FIS 23.62 23.62 22.74 23.04 47769 20100208 FIS 23 23.12 22.8 22.92 28764 20100209 FIS 23.17 23.44 22.74 22.78 45553 20100210 FIS 22.73 22.78 22.27 22.28 53012 20100211 FIS 22.28 22.52 22.25 22.47 38774 20100212 FIS 22.3 22.5 22.13 22.36 41519 20100216 FIS 22.48 22.64 22.36 22.52 19539 20100217 FIS 22.61 22.61 22.32 22.61 28800 20100218 FIS 22.56 22.78 22.41 22.61 37029 20100219 FIS 22.48 22.79 22.42 22.68 28900 20100222 FIS 22.71 22.84 22.6 22.65 18346 20100223 FIS 22.65 22.81 22.45 22.6 26523 20100224 FIS 22.68 22.92 22.445 22.88 - ---- - -13.24 141302 20100802 DELL 13.43 13.68 13.35 13.61 104059 20100803 DELL 13.55 13.6 13.34 13.42 91235 20100804 DELL 13.48 13.53 13.07 13.21 203854 20100805 DELL 13.08 13.22 12.87 13.13 253347 20100806 DELL 13 13.12 12.87 13.12 162920 20100809 DELL 13.23 13.24 12.91 12.98 179507 20100810 DELL 12.77 12.81 12.37 12.45 373440 20100811 DELL 12.24 12.27 11.84 12.1 298803 20100812 DELL 11.8 12.12 11.76 11.99 208530 20100813 DELL 12.03 12.18 11.99 12.01 176413 20100816 DELL 11.9 12.0801 11.8 11.96 131415 20100819 DELL 12.09 12.18 11.97 12.04 300258 20100820 DELL 11.84 12.24 11.8 12.07 502579 20090821 DF 18.35 18.35 17.91 18.11 28269 20090824 DF 18.17 18.25 17.66 17.92 19673 20090825 DF 18 18.15 17.78 17.99 17852 20090826 DF 18 18.33 17.81 18.23 24255 20090827 DF 18.16 18.31 18.05 18.27 13047 20090828 DF 18.31 18.31 18.01 18.18 17527 20090831 DF 18.06 18.27 17.9 18.14 18156 20090901 DF 18.13 18.17 17.57 17.6 29563 20090902 DF 17.48 17.8 17.45 17.73 24926 20090903 DF 17.85 18.36 17.63 18.32 29932 20090904 DF 18.36 18.47 18.15 18.19 19262 20090909 DF 18.12 18.28 17.9 18.08 20513 20090910 DF 18.1 18.23 18 18.09 21150 20090911 DF 18.15 18.25 17.98 18.12 14457 20090914 DF 18.03 18.41 18.01 18.27 18133 20090915 DF 18.28 18.3 18.1 18.25 22024 20090916 DF 18.24 18.4 18.02 18.25 13368 20090917 DF 18.25 18.4 18.02 18.03 18252 20090918 DF 18.05 18.47 18.05 18.4 24422 20090921 DF 18.27 18.39 18.2 18.32 16549 20090922 DF 18.36 18.36 18.05 18.08 16453 20090923 DF 18.1 18.4 17.94 18.2 30254 20090924 DF 18.23 18.36 17.9 18 21350 20090925 DF 17.95 18.07 17.78 17.84 18462 20090928 DF 17.84 18.09 17.84 17.96 8102 20090929 DF 17.98 18.02 17.695 17.78 18967 20090930 DF 17.77 17.84 17.45 17.79 23502 20091001 DF 17.78 18.22 17.58 18.15 42561 20091002 DF 18.05 18.875 17.97 18.77 58295 20091005 DF 18.83 18.96 18.59 18.89 33102 20091006 DF 18.97 19.12 18.56 18.61 41803 20091007 DF 18.48 18.68 18.47 18.65 33162 20091008 DF 18.72 19.18 18.71 19.16 23017 20091009 DF 19.1 19.44 19 19.27 34421 20091012 DF 19.24 19.43 19.1 19.24 19142 20091013 DF 19.16 19.3 18.91 19.13 39026 20091014 DF 19.11 19.29 19.09 19.23 30246 20091015 DF 19.25 19.5 19.055 19.43 23836 20091016 DF 19.36 19.75 19.251 19.64 25898 20091019 DF 19.69 19.76 19.55 19.65 21840 20091020 DF 19.44 19.495 18.97 19.03 26519 20091021 DF 19.05 19.26 18.74 18.74 27524 20091022 DF 18.76 18.84 18.52 18.77 16855 20091023 DF 18.75 18.77 18.19 18.26 19981 20091026 DF 18.26 18.7 18.23 18.33 28651 20091027 DF 18.41 18.4899 18.07 18.07 26389 20091028 DF 18.14 18.23 17.84 17.84 27831 20091105 DF 16.96 17.14 16.82 17.01 29876 20091106 DF 16.87 17.08 16.68 16.78 27193 20091109 DF 17 17 16.81 16.89 30305 20091110 DF 16.8 17.02 16.69 16.81 21091 20091111 DF 16.94 16.95 16.61 16.76 30867 20091112 DF 16.73 16.8 16.41 16.44 32167 20091113 DF 16.42 16.46 16.14 16.28 31961 20091116 DF 16.42 16.49 16.2 16.3 30319 20091117 DF 16.29 16.37 15.97 16.04 34347 20091118 DF 16.13 16.33 15.95 15.96 56118 20091119 DF 15.97 16.04 15.75 15.94 43546 20091120 DF 15.88 16.22 15.77 16.12 33306 20091123 DF 16.26 16.34 16.15 16.29 31231 20091124 DF 16.37 16.47 16.14 16.29 37691 20091125 DF 16.35 16.4 16.11 16.19 19152 20091127 DF 15.9 16.14 15.77 16.07 11074 20091130 DF 16.15 16.17 15.74 15.9 27355 20091201 DF 16.08 16.26 15.93 16.21 30320 20091202 DF 16.24 16.44 16.11 16.38 22430 20091203 DF 16.45 16.52 16.31 16.35 21590 20091204 DF 16.43 16.8 16.41 16.8 41831 20091207 DF 16.82 17 16.74 16.82 31588 20091208 DF 16.88 17.14 16.69 17.06 35313 20091209 DF 17.1 17.17 16.89 17.15 27013 20091210 DF 17.24 17.24 16.91 16.98 24269 20091211 DF 17.02 17.43 17.02 17.25 22856 20091214 DF 17.31 17.58 17.12 17.26 17543 20091215 DF 17.14 17.42 17.1 17.29 22973 20091216 DF 17.33 17.54 17.18 17.23 19187 20091217 DF 17.1 17.19 16.86 17.11 22721 20091218 DF 17.13 17.33 17.125 17.31 22737 20091221 DF 17.33 17.8 17.33 17.68 19475 20091222 DF 17.53 18 17.53 17.99 24927 20091223 DF 17.98 18.54 17.98 18.43 25260 20091224 DF 18.37 18.48 18.24 18.27 6472 20091228 DF 18.25 - ---- - -7.12 10638 20090903 NYT 7.14 7.26 6.94 7.14 6390 20090904 NYT 7.13 7.21 6.86 7.14 7618 20090909 NYT 7.23 7.39 7.14 7.37 6876 20090910 NYT 7.37 7.81 7.26 7.72 14066 20090911 NYT 7.74 7.94 7.67 7.78 14374 20090914 NYT 7.68 7.78 7.46 7.73 7965 20090915 NYT 7.7 7.91 7.57 7.88 10038 20090916 NYT 8 8.86 7.9 8.82 23639 20090917 NYT 8.78 9.34 8.3501 8.42 23484 20090918 NYT 8.57 8.57 8.2505 8.36 24884 20090921 NYT 8.25 8.3 7.85 8.16 12911 20090922 NYT 8.23 8.6801 8.16 8.37 19439 20090923 NYT 8.41 8.55 8.08 8.12 16989 20090924 NYT 8.16 8.19 7.69 7.75 12706 20090925 NYT 7.74 7.985 7.47 7.78 10106 20090928 NYT 7.74 8.08 7.67 7.99 10531 20090929 NYT 8.7 8.86 8.26 8.39 42478 20090930 NYT 8.35 8.47 8 8.12 24738 20091001 NYT 8.08 8.14 7.6 7.75 14317 20091002 NYT 7.64 7.67 7.25 7.32 13087 20091005 NYT 7.33 7.85 7.28 7.81 15536 20091006 NYT 7.9 8.39 7.74 8.2 21294 20091007 NYT 8.19 8.22 7.92 8.03 17398 20091008 NYT 8.11 8.62 8.06 8.59 17466 20091009 NYT 8.57 8.65 8.36 8.48 8154 20091012 NYT 8.48 8.65 8.29 8.39 7292 20091013 NYT 8.34 8.39 8.09 8.31 7336 20091014 NYT 8.51 8.7 8.14 8.67 13422 20091015 NYT 8.44 8.92 8.35 8.67 21474 20091016 NYT 8.57 8.72 8.37 8.48 9449 20091019 NYT 8.52 8.93 8.23 8.91 15153 20091020 NYT 9.07 9.07 8.63 8.65 12572 20091021 NYT 8.65 9.08 8.49 8.75 19988 20091022 NYT 9.75 10.84 9.51 10.72 65884 20091023 NYT 10.65 11.05 10.41 10.74 34202 20091026 NYT 10.86 10.93 9.94 10.08 26626 20091027 NYT 10.06 10.25 9.62 9.71 19278 20091028 NYT 9.57 9.62 8.51 8.56 45601 20091105 NYT 7.71 8.28 7.71 8.26 23206 20091106 NYT 7.97 8.41 7.97 8.17 19497 20091109 NYT 8.21 8.705 8.14 8.63 20685 20091110 NYT 8.59 8.81 8.47 8.67 17144 20091111 NYT 8.81 9.15 8.81 8.99 21574 20091112 NYT 8.94 9.2 8.86 8.91 16559 20091113 NYT 8.97 9.17 8.82 8.95 17358 20091116 NYT 9.08 9.6222 8.97 9.55 15899 20091117 NYT 9.5 9.58 9.235 9.55 9973 20091118 NYT 9.46 9.515 9.16 9.25 14866 20091119 NYT 9.16 9.17 8.69 8.84 14683 20091120 NYT 8.86 8.86 8.36 8.65 10192 20091123 NYT 8.97 9.1 8.84 8.91 12416 20091124 NYT 8.89 9.15 8.73 8.88 8667 20091125 NYT 8.92 9.04 8.8897 8.99 8287 20091127 NYT 8.49 8.87 8.32 8.76 6218 20091130 NYT 8.7 8.78 8.34 8.44 17322 20091201 NYT 8.68 8.8 8.48 8.6 10600 20091202 NYT 8.6 8.78 8.39 8.52 8992 20091203 NYT 8.61 8.8 8.55 8.55 12283 20091204 NYT 8.65 8.9 8.34 8.72 16419 20091207 NYT 8.61 9.03 8.61 8.9 30424 20091208 NYT 8.9 9.29 8.62 9.01 26967 20091209 NYT 8.98 9.02 8.7301 8.96 26400 20091210 NYT 8.89 9.32 8.88 9.08 44478 20091211 NYT 9.18 9.24 8.98 9.19 17117 20091214 NYT 9.34 9.75 9.2 9.69 21008 20091215 NYT 9.67 10.12 9.515 10.1 25842 20091216 NYT 10.02 10.75 10.02 10.68 38970 20091217 NYT 10.59 10.59 10.23 10.25 18358 20091218 NYT 10.56 11.11 10.1 10.4 40894 20091221 NYT 10.68 10.84 10.3805 10.79 34244 20091222 NYT 10.97 11.18 10.7 11.03 26988 20091223 NYT 11.99 12.11 11.46 12.1 46480 20091224 NYT 12.09 12.46 12.09 12.16 10373 20091228 NYT 12.21 12.255 12.11 12.22 14701 20091229 NYT 12.31 12.41 12 12.13 15155 20091230 NYT 12.095 12.75 12.05 12.63 27141 20091231 NYT 12.63 12.6492 12.34 12.36 21647 20100104 NYT 12.65 13.19 12.49 13.03 25360 20100105 NYT 13.04 13.87 13 13.46 43969 20100106 NYT 13.47 13.9301 13.37 13.76 25803 20100107 NYT 13.64 14.22 13.58 14.2 22539 20100108 NYT 14.09 14.191 13.75 14.11 18034 20100111 NYT 14.12 14.87 14.05 14.67 29469 20100112 NYT 14.48 14.69 13.59 13.86 30774 20100113 NYT 13.98 14.06 13.47 13.9 24796 20100114 NYT 13.77 14.1 13.6 13.95 17534 20100115 NYT 13.89 13.98 13.04 13.33 25775 20100119 NYT 13.34 13.72 13.23 13.7 20288 20100120 NYT 13.43 13.69 13.05 13.31 29100 20100121 NYT 13.3 13.64 12.7 12.71 30263 20100122 NYT 12.6 13.17 12.43 12.45 21357 20100125 NYT 12.7 12.7 12.12 12.51 19892 20100126 NYT 12.38 13.24 12.38 13.02 27401 20100127 NYT 13.26 13.94 12.94 13.23 29590 20100128 NYT 13.27 13.4 12.66 13.01 14562 20100129 NYT 13.06 13.47 12.85 12.92 22890 20100201 NYT 12.84 12.93 12.15 12.49 27050 20100202 NYT 12.6 12.82 12.34 12.69 15613 20100203 NYT 12.66 13.37 12.46 12.49 23979 20100204 NYT 12.3 - ---- - -24.76 137482 20090915 TXN 24.89 25 24.64 24.83 119897 20090916 TXN 24.88 24.88 24 24.13 162048 20090917 TXN 24.1 24.2 23.6 23.6 194796 20090918 TXN 23.79 24.21 23.62 24.06 181645 20090921 TXN 23.96 24.23 23.81 23.97 112035 20090922 TXN 24.2 24.2 23.57 23.76 161261 20090923 TXN 23.89 24.55 23.86 24.05 168747 20090924 TXN 24.08 24.15 23.46 23.57 136109 20090925 TXN 23.42 23.76 23.152 23.35 135947 20090928 TXN 23.5 24.18 23.42 23.91 114289 20090929 TXN 23.96 24.37 23.515 23.55 153270 20090930 TXN 23.67 24.12 23.47 23.69 186468 20091001 TXN 23.52 23.74 22.6 22.65 221998 20091002 TXN 22.45 22.77 22.26 22.49 204233 20091005 TXN 22.59 22.93 22.49 22.6 185287 20091006 TXN 22.85 23.24 22.79 23.1 169763 20091007 TXN 22.99 23.11 22.67 22.82 140129 20091008 TXN 22.93 22.93 22.26 22.53 218869 20091009 TXN 22.48 23.65 22.48 23.64 206518 20091012 TXN 23.71 24.31 23.59 23.8 179585 20091013 TXN 23.91 24.02 23.46 23.62 149151 20091014 TXN 24.02 24.07 23.35 23.62 225334 20091015 TXN 23.39 23.46 23.13 23.25 166642 20091016 TXN 23.12 23.12 22.54 22.75 239165 20091019 TXN 23 23.55 22.89 23.52 360348 20091020 TXN 24.11 24.11 23.51 23.66 304120 20091021 TXN 23.64 23.78 22.85 23 277262 20091022 TXN 22.87 23.92 22.87 23.88 325954 20091023 TXN 24 24 23.38 23.5 235982 20091026 TXN 23.38 23.96 23.3075 23.7 197530 20091027 TXN 24.03 24.35 23.69 23.8 293375 20091028 TXN 23.93 24.56 23.41 23.44 289378 20091105 TXN 23.8 24.31 23.65 24.18 131489 20091106 TXN 24.06 24.48 23.93 24.04 117565 20091109 TXN 24.15 24.71 24.03 24.63 106136 20091110 TXN 24.6 25.27 24.58 25.05 194136 20091111 TXN 25.15 25.69 25.13 25.33 146860 20091112 TXN 25.26 25.85 25.19 25.37 133259 20091113 TXN 25.44 25.68 25.24 25.44 103365 20091116 TXN 25.57 26.08 25.52 25.95 123840 20091117 TXN 25.82 25.97 25.57 25.87 109403 20091118 TXN 25.83 25.94 25.4775 25.75 107571 20091119 TXN 24.8 24.96 24.45 24.88 196354 20091120 TXN 24.75 25 24.65 24.74 132528 20091123 TXN 24.93 25.39 24.89 25.14 90201 20091124 TXN 25.18 25.54 25.14 25.28 112915 20091125 TXN 25.34 25.45 25.18 25.42 82818 20091127 TXN 24.8 25.4 24.56 25.25 72784 20091130 TXN 25.35 25.39 25.03 25.29 124688 20091201 TXN 25.55 26.03 25.29 25.94 158424 20091202 TXN 26.01 26.33 25.72 25.96 206741 20091203 TXN 26.06 26.68 26 26.44 144666 20091204 TXN 26.74 27 26.34 26.85 163391 20091207 TXN 26.71 27 26.43 26.62 126258 20091208 TXN 26.72 26.9 25.12 26.33 182153 20091209 TXN 25.76 25.99 25.51 25.99 227332 20091210 TXN 26.08 26.19 25.54 25.94 201188 20091211 TXN 25.9 26.06 25.5 25.64 98964 20091214 TXN 25.76 26.07 25.695 25.98 84834 20091215 TXN 25.88 25.89 25.4 25.44 113230 20091216 TXN 25.57 26.08 25.44 25.58 143289 20091217 TXN 25.33 25.6 25.06 25.08 107356 20091218 TXN 25.36 25.54 25.06 25.46 135455 20091221 TXN 25.71 25.99 25.52 25.84 77296 20091222 TXN 25.87 26.01 25.56 25.64 72096 20091223 TXN 25.44 25.62 25.27 25.32 82274 20091224 TXN 25.36 25.85 25.32 25.83 39777 20091228 TXN 25.78 25.84 25.34 25.49 87818 20091229 TXN 25.51 25.59 25.28 25.37 60886 20091230 TXN 25.42 25.98 25.31 25.98 71803 20091231 TXN 25.95 26.27 25.94 26.06 84327 20100104 TXN 26.2 26.61 25.89 26.01 103693 20100105 TXN 25.95 26.3 25.7 25.86 109437 20100106 TXN 25.9 26.03 25.56 25.67 89338 20100107 TXN 25.6 25.84 25.36 25.75 107755 20100108 TXN 25.6 26.34 25.52 26.34 128756 20100111 TXN 26.21 26.49 25.72 26 116786 20100112 TXN 26.02 26.03 24.67 24.91 211653 20100113 TXN 25.01 25.16 24.67 25.02 188092 20100114 TXN 24.89 25 24.48 24.71 229143 20100115 TXN 24.68 24.77 24.2 24.5 203598 20100119 TXN 24.45 24.78 24.35 24.72 117859 20100120 TXN 24.52 24.61 24.2 24.55 132536 20100121 TXN 24.55 24.88 24.01 24.18 184079 20100122 TXN 24.1 24.17 23 23.11 218077 20100125 TXN 23.41 23.82 23.2 23.69 201920 20100126 TXN 23.39 23.9 23.29 23.35 196508 20100127 TXN 23.37 23.66 23.08 23.53 195358 20100128 TXN 23.46 23.51 22.69 23.05 202002 20100129 TXN 23.11 23.37 22.28 22.5 231372 20100201 TXN 22.56 23.08 22.56 23.05 131989 20100202 TXN 22.97 23.37 22.94 23.31 118910 20100203 TXN 23.26 - ---- - -IPG 7.24 7.37 7.04 7.36 89323 20090917 IPG 7.32 7.39 7.12 7.28 66142 20090918 IPG 7.35 7.56 7.35 7.47 60774 20090921 IPG 7.4 7.49 7.13 7.4 62907 20090922 IPG 7.18 7.45 7.16 7.2 51463 20090923 IPG 7.23 7.49 7.21 7.26 71708 20090924 IPG 7.29 7.32 6.9 7.04 69009 20090925 IPG 7.01 7.19 6.95 7.02 39633 20090928 IPG 6.99 7.32 6.98 7.3 30317 20090929 IPG 7.4 7.63 7.35 7.59 82616 20090930 IPG 7.6 7.77 7.45 7.52 117214 20091001 IPG 7.45 7.5 7.03 7.06 63095 20091002 IPG 6.95 7.06 6.79 6.84 83682 20091005 IPG 6.82 7.03 6.75 6.92 62810 20091006 IPG 6.95 7.21 6.92 7.11 52387 20091007 IPG 7.14 7.15 6.8 6.88 67688 20091008 IPG 6.94 7.13 6.9 7.09 67312 20091009 IPG 7.1 7.15 7 7.07 31903 20091012 IPG 7.09 7.19 6.93 6.96 32964 20091013 IPG 6.98 7.11 6.94 7.04 37116 20091014 IPG 7.14 7.15 6.91 7.01 97043 20091015 IPG 6.97 7.22 6.64 6.87 63644 20091016 IPG 6.78 6.85 6.47 6.79 102166 20091019 IPG 6.82 6.82 6.67 6.72 76828 20091020 IPG 6.72 6.8 6.44 6.49 94219 20091021 IPG 6.41 6.54 6.17 6.17 115282 20091022 IPG 6.2 6.37 6.13 6.34 70891 20091023 IPG 6.39 6.41 6.07 6.12 62433 20091026 IPG 6.14 6.31 6.02 6.06 84866 20091027 IPG 6.05 6.2 5.92 6.11 96031 20091028 IPG 6.24 6.47 5.89 5.96 177283 20091105 IPG 6.21 6.4 6.17 6.38 57918 20091106 IPG 6.36 6.56 6.31 6.47 56087 20091109 IPG 6.52 6.79 6.47 6.77 55186 20091110 IPG 6.75 6.815 6.61 6.7 39994 20091111 IPG 6.79 6.91 6.73 6.87 49326 20091112 IPG 6.87 6.97 6.57 6.59 67202 20091113 IPG 6.63 6.85 6.56 6.77 43970 20091116 IPG 6.78 7.06 6.78 7.02 37393 20091117 IPG 6.93 7.05 6.78 6.86 39452 20091118 IPG 6.86 6.89 6.69 6.87 26369 20091119 IPG 6.81 6.84 6.64 6.77 43272 20091120 IPG 6.71 6.89 6.63 6.83 42567 20091123 IPG 6.84 7.01 6.68 6.74 35855 20091124 IPG 6.5 6.74 6.32 6.55 54565 20091125 IPG 6.53 6.63 6.49 6.61 30862 20091127 IPG 6.38 6.52 6.09 6.46 15082 20091130 IPG 6.45 6.5 6.21 6.33 39586 20091201 IPG 6.38 6.51 6.33 6.47 38496 20091202 IPG 6.42 6.62 6.42 6.49 36654 20091203 IPG 6.49 6.55 6.39 6.42 27907 20091204 IPG 6.43 6.55 6.21 6.36 73351 20091207 IPG 6.36 6.63 6.31 6.55 56968 20091208 IPG 6.6 6.91 6.47 6.9 86326 20091209 IPG 6.92 7.03 6.8 6.93 82481 20091210 IPG 7.05 7.29 6.95 7.18 93080 20091211 IPG 7.24 7.28 7.11 7.24 38193 20091214 IPG 7.24 7.57 7.2 7.53 60945 20091215 IPG 7.4 7.51 7.36 7.46 59149 20091216 IPG 7.52 7.55 7.32 7.4 51605 20091217 IPG 7.24 7.4 7.14 7.14 39066 20091218 IPG 7.15 7.23 7.14 7.17 79754 20091221 IPG 7.29 7.29 7.08 7.17 41917 20091222 IPG 7.16 7.22 7.1099 7.18 40949 20091223 IPG 7.16 7.26 7.11 7.22 33797 20091224 IPG 7.28 7.41 7.21 7.4 17566 20091228 IPG 7.49 7.49 7.15 7.25 24456 20091229 IPG 7.28 7.3095 7.175 7.2 21556 20091230 IPG 7.15 7.29 7.13 7.28 23348 20091231 IPG 7.46 7.62 7.33 7.38 42574 20100104 IPG 7.45 7.62 7.4 7.53 44442 20100105 IPG 7.54 7.54 7.41 7.45 61346 20100106 IPG 7.4 7.46 7.32 7.45 55860 20100107 IPG 7.37 7.45 7.19 7.26 62023 20100108 IPG 7.27 7.3 7.08 7.27 64807 20100111 IPG 7.25 7.47 7.22 7.47 52904 20100112 IPG 7.41 7.41 7.23 7.29 46306 20100113 IPG 7.31 7.45 7.19 7.38 35044 20100114 IPG 7.4 7.46 7.14 7.22 115065 20100115 IPG 7.17 7.24 6.98 7.16 87290 20100119 IPG 7.18 7.21 7.07 7.12 36478 20100120 IPG 7.03 7.16 6.95 7.15 50447 20100121 IPG 7.24 7.33 6.98 7.01 61345 20100122 IPG 6.99 7.02 6.81 6.85 56339 20100125 IPG 6.94 6.94 6.76 6.78 36300 20100126 IPG 6.73 6.82 6.6299 6.66 47012 20100127 IPG 6.61 6.63 6.38 6.47 98689 20100128 IPG 6.5 6.665 6.455 6.52 58320 20100129 IPG 6.58 6.61 6.41 6.46 67687 20100201 IPG 6.52 6.65 6.47 6.6 71305 20100202 IPG 6.63 6.76 6.52 6.72 60275 20100203 IPG 6.73 6.88 6.59 6.69 52549 20100204 IPG 6.63 6.67 6.37 6.41 63721 20100205 IPG 6.57 6.57 6.21 6.39 104504 20100208 IPG 6.44 6.51 6.2875 6.35 72215 20100209 IPG 6.44 6.5 6.31 6.4 83942 20100210 IPG 6.34 6.66 6.33 6.5 79019 20100211 IPG 6.49 6.76 6.4 6.73 62576 20100212 IPG 6.7 6.74 6.6 6.72 54805 20100216 IPG 6.82 6.9 6.77 6.87 42815 20100217 IPG 6.89 7.02 6.84 6.98 59219 20100218 IPG 6.98 7.12 6.92 7.09 46492 20100219 IPG 7.05 7.19 7.02 7.11 31640 20100222 IPG 7.15 - ---- - -16.34 16.11 16.27 30563 20100618 WU 16.23 16.35 16.15 16.2 47364 20100621 WU 16.4 16.5 15.92 16 44432 20100622 WU 16 16.08 15.76 15.78 47891 20100623 WU 15.71 15.89 15.505 15.8 45359 20100624 WU 15.73 15.8 15.48 15.53 70021 20100625 WU 15.6 16.04 15.42 16 124921 20100628 WU 16.09 16.1 15.74 15.74 46458 20100629 WU 15.53 15.53 14.83 14.94 110267 20100630 WU 15.01 15.12 14.87 14.91 80619 20100701 WU 14.91 15.11 14.65 15.03 89206 20100702 WU 15.15 15.22 14.83 14.9 58788 20100706 WU 15.17 15.44 14.93 15.06 49627 20100707 WU 15.14 15.85 15.14 15.7875 97018 20100708 WU 15.86 15.95 15.49 15.63 85511 20100709 WU 15.67 15.88 15.55 15.87 41569 20100712 WU 15.79 15.97 15.72 15.9 36248 20100713 WU 16 16.08 15.79 16 85499 20100714 WU 16.03 16.03 15.81 15.96 37854 20100715 WU 15.94 16.03 15.68 15.98 63416 20100716 WU 15.83 15.84 15.22 15.34 96620 20100719 WU 15.36 15.5 15.23 15.37 51674 20100720 WU 15.14 15.7 15.14 15.69 41507 20100721 WU 15.79 15.81 15.35 15.44 56231 20100722 WU 15.61 16.18 15.59 16.04 100536 20100723 WU 16.03 16.34 15.93 16.31 47876 20100726 WU 16.37 16.71 16.3 16.68 91184 20100727 WU 17 17.205 16.57 16.69 96062 20100728 WU 16.62 16.64 16.43 16.47 56360 20100729 WU 16.56 16.67 16.1519 16.41 83881 20100730 WU 15.82 16.44 15.82 16.23 74224 20100802 WU 16.44 16.59 16.07 16.28 81222 20100803 WU 16.24 16.269 15.99 16.03 61259 20100804 WU 16.04 16.15 15.8299 16.13 50838 20100805 WU 16.06 16.29 16.06 16.22 29934 20100806 WU 16.04 16.32 15.97 16.29 48008 20100809 WU 16.37 16.58 16.33 16.54 42737 20100810 WU 16.29 16.66 16.29 16.5 48636 20100811 WU 16.23 16.23 15.99 16.05 47736 20100812 WU 15.81 16.16 15.78 16.06 52099 20100813 WU 15.98 16.17 15.95 15.98 35446 20100816 WU 15.88 16.23 15.82 16.1 28857 20100817 WU 16.18 16.44 16.16 16.18 38698 20100819 WU 16.15 16.21 15.95 16.06 47403 20100820 WU 15.95 16.1 15.88 15.94 35871 20090821 WY 36.29 37.31 35.89 37.02 19789 20090824 WY 37.29 37.45 36.11 36.32 13971 20090825 WY 36.69 37.31 36.27 36.46 17749 20090826 WY 36.54 37.49 36.11 36.79 17052 20090827 WY 36.58 37.44 35.83 37.33 15152 20090828 WY 37.64 37.98 36.92 37.79 15378 20090831 WY 37.16 37.5 36.7 37.39 16364 20090901 WY 37.28 37.92 35.74 35.85 28418 20090902 WY 35.65 36.41 35.39 36.06 19765 20090903 WY 36.29 36.82 35.296 36.75 20133 20090904 WY 36.65 37.15 36.26 37.09 15748 20090909 WY 36.61 37.21 36.35 36.77 18627 20090910 WY 36.62 37.12 36.04 37 20146 20090911 WY 37.11 38.13 36.51 37.29 54748 20090914 WY 36.99 39.66 36.9 39.59 41352 20090915 WY 39.55 40.4346 38.2 39.38 45920 20090916 WY 39.22 39.91 38.61 39.87 24408 20090917 WY 40 40.36 38.42 38.69 28238 20090918 WY 38.8 39.88 38.77 39.65 27009 20090921 WY 39.08 39.68 38.03 38.51 20457 20090922 WY 38.94 39.28 38.62 38.85 13928 20090923 WY 38.89 39.27 38.08 38.13 13837 20090924 WY 38.27 38.36 36.25 36.4 25084 20090925 WY 36.14 37.33 36.11 36.95 18757 20090928 WY 37 37.66 36.58 37.35 9467 20090929 WY 37.35 38.22 37.26 37.38 12214 20090930 WY 37.52 37.61 36.1 36.65 24998 20091001 WY 36.29 36.6 35.68 35.68 30671 20091002 WY 35.61 35.61 34.68 35.08 32382 20091005 WY 35.26 35.56 34.37 35.32 23518 20091006 WY 35.88 36.14 35.25 35.65 21610 20091007 WY 35.54 35.75 34.65 34.88 20476 20091008 WY 35.39 36.62 35.09 36.48 40720 20091009 WY 36.52 36.7 36.11 36.35 25214 20091012 WY 36.435 37.4 36.38 36.83 18638 20091013 WY 36.85 37.85 36.76 37.72 19299 20091014 WY 38.04 39.35 38.04 39.23 28226 20091015 WY 39.06 40.04 38.91 40 26520 20091016 WY 39.79 40.22 39.0106 40.11 30640 20091019 WY 40.01 41 40 40.67 26157 20091020 WY 40.54 40.74 39.98 40.66 21031 20091021 WY 40.5 41.28 40.19 40.26 24603 20091022 WY 40.26 41 39.46 40.83 22412 20091023 WY 40.83 40.83 39.211 39.48 15280 20091026 WY 39.38 40.45 38.21 38.43 22126 20091027 WY 38.33 38.94 38.05 38.18 21814 20091028 WY 37.89 38.5 36.01 36.21 33318 20091105 WY 36.86 38.05 36.86 37.78 22301 20091106 WY 37.24 37.99 36.79 37.62 15183 20091109 WY 37.75 38.87 37.75 38.82 12880 20091110 WY 38.62 38.93 38.091 38.8 12186 20091111 WY 39.04 39.5 38.52 38.9 - ---- - -11275 20091125 STZ 17.38 17.48 17.27 17.42 10117 20091127 STZ 17.09 17.2 16.88 16.99 8384 20091130 STZ 17.05 17.24 16.9 17.11 12939 20091201 STZ 17.3 17.46 17.21 17.25 15017 20091202 STZ 16.44 16.8 16.105 16.77 59537 20091203 STZ 16.81 16.81 16.45 16.53 23128 20091204 STZ 16.71 16.97 16.64 16.74 18418 20091207 STZ 16.69 16.89 16.47 16.59 17425 20091208 STZ 16.5 16.52 16.09 16.17 20189 20091209 STZ 16.16 16.19 15.815 15.98 16213 20091210 STZ 16.01 16.16 15.69 15.81 22973 20091211 STZ 15.83 16.01 15.79 15.98 15597 20091214 STZ 16.15 16.15 16.01 16.08 15580 20091215 STZ 16.06 16.21 16.06 16.17 10457 20091216 STZ 15.66 15.8 15.02 15.11 62654 20091217 STZ 15.08 15.17 14.91 15.12 31853 20091218 STZ 15.13 15.42 15.11 15.35 45756 20091221 STZ 15.45 15.52 15.29 15.48 21955 20091222 STZ 15.54 15.78 15.38 15.74 16545 20091223 STZ 15.84 15.87 15.61 15.77 10092 20091224 STZ 15.78 15.93 15.77 15.92 3494 20091228 STZ 15.88 16.05 15.86 16.05 7308 20091229 STZ 16.04 16.12 15.97 15.97 8880 20091230 STZ 15.99 16.01 15.83 15.99 6262 20091231 STZ 15.98 16.076 15.92 15.93 8433 20100104 STZ 16.02 16.17 15.89 16.12 14187 20100105 STZ 16.08 16.13 15.86 15.92 24315 20100106 STZ 15.94 16.17 15.72 16.13 28393 20100107 STZ 15.6 16.2 15.1 15.97 38706 20100108 STZ 15.88 15.88 15.55 15.66 21002 20100111 STZ 15.66 15.8 15.53 15.69 15359 20100112 STZ 15.63 15.75 15.52 15.65 17628 20100113 STZ 15.64 15.995 15.61 15.91 15187 20100114 STZ 15.98 16.48 15.98 16.33 24669 20100115 STZ 16.37 16.55 16.29 16.41 23846 20100119 STZ 16.38 16.84 16.38 16.82 23345 20100120 STZ 16.66 16.835 16.54 16.83 26553 20100121 STZ 16.72 17.04 16.72 16.79 24022 20100122 STZ 16.71 16.85 16.5 16.61 21100 20100125 STZ 16.8 16.8 16.46 16.61 12742 20100126 STZ 16.47 16.62 16.41 16.42 10011 20100127 STZ 16.4 16.48 16.06 16.34 11205 20100128 STZ 16.41 16.45 16.1 16.17 7348 20100129 STZ 16.23 16.27 16.03 16.08 14613 20100201 STZ 16.18 16.29 16.07 16.23 9985 20100202 STZ 16.28 16.42 16.1185 16.39 8290 20100203 STZ 16.36 16.42 16.19 16.31 6851 20100204 STZ 16.16 16.2 15.41 15.45 19938 20100205 STZ 15.4 15.51 14.95 15.33 32114 20100208 STZ 15.37 15.37 14.87 14.93 22056 20100209 STZ 15.17 15.33 14.96 15.2 15097 20100210 STZ 15.17 15.24 14.91 15.13 16157 20100211 STZ 15.18 15.53 15.08 15.49 13514 20100212 STZ 15.38 15.59 15.28 15.36 19741 20100216 STZ 15.43 15.61 15.37 15.61 8394 20100217 STZ 15.65 15.84 15.55 15.68 13603 20100218 STZ 15.61 15.8 15.56 15.59 14479 20100219 STZ 15.48 15.625 15.33 15.6 15898 20100222 STZ 15.61 15.68 15.47 15.53 9583 20100223 STZ 15.46 15.46 15.03 15.22 22399 20100224 STZ 15.24 15.25 14.96 15.02 27108 20100225 STZ 14.85 14.91 14.6 14.83 43600 20100226 STZ 14.9 15.09 14.83 15.04 16115 20100301 STZ 15.15 15.26 15.06 15.26 10710 20100302 STZ 15.29 15.52 15.21 15.47 13649 20100303 STZ 15.45 15.66 15.42 15.43 14983 20100304 STZ 15.39 15.59 15.36 15.57 10967 20100305 STZ 15.65 15.85 15.58 15.81 11186 20100308 STZ 15.82 15.83 15.67 15.78 15965 20100309 STZ 15.71 15.92 15.67 15.81 18154 20100310 STZ 15.83 15.88 15.54 15.62 18492 20100311 STZ 15.55 15.83 15.54 15.83 11045 20100312 STZ 15.83 16.14 15.83 16.11 16270 20100315 STZ 16.06 16.23 15.96 16.13 10765 20100316 STZ 16.11 16.23 15.99 16.17 8225 20100317 STZ 16.18 16.28 16.09 16.24 8283 20100318 STZ 16.215 16.3 16.03 16.19 15191 20100319 STZ 16.25 16.31 15.96 16 17313 20100322 STZ 15.91 16.15 15.85 16.11 12863 20100323 STZ 16.08 16.39 16.03 16.37 10701 20100324 STZ 16.28 16.38 16.13 16.22 10449 20100325 STZ 16.35 16.39 16.16 16.18 11964 20100326 STZ 16.21 16.225 16 16.01 11169 20100329 STZ 16.06 16.35 16.05 16.31 9871 20100330 STZ 16.36 16.57 16.36 16.42 9572 20100331 STZ 16.39 16.56 16.2799 16.44 13696 20100401 STZ 16.51 16.6 16.33 16.5 12125 20100405 STZ 16.51 16.72 16.43 16.67 8231 20100406 STZ 16.74 17.01 16.6 17 14899 20100407 STZ 16.9 17.12 16.83 16.84 16576 20100408 STZ 16.85 17 16.77 16.85 22161 20100409 STZ 16.01 16.54 15.95 16.43 49175 20100412 STZ 16.47 17.23 16.28 17.15 39231 20100413 STZ 17.09 17.1501 16.89 17.07 - ---- - -21.79 49643 20091020 NVLS 21.69 22.07 21.65 21.83 55248 20091021 NVLS 21.73 21.99 21.5 21.61 61336 20091022 NVLS 21.79 23.13 21.34 23.08 86835 20091023 NVLS 23.03 23.17 22.3 22.5 55483 20091026 NVLS 22.55 22.91 22.15 22.31 45552 20091027 NVLS 22.19 22.59 21.52 21.62 38032 20091028 NVLS 21.65 21.87 20.8 20.82 33470 20091105 NVLS 20.04 20.41 19.94 20.27 20684 20091106 NVLS 20.22 20.62 20.11 20.37 18873 20091109 NVLS 20.58 21.11 20.57 21.07 16542 20091110 NVLS 21.05 21.28 20.9 21.16 24642 20091111 NVLS 21.24 21.73 21.2 21.55 18712 20091113 NVLS 21.35 21.64 21.2 21.63 21774 20091116 NVLS 21.71 22.42 21.71 22.32 27889 20091117 NVLS 22.09 22.36 21.92 22.17 17857 20091118 NVLS 22.18 22.22 21.76 21.8 14999 20091119 NVLS 21.55 21.59 20.82 20.89 30592 20091120 NVLS 20.8 21.035 20.66 20.96 46268 20091123 NVLS 21.2 21.58 21.06 21.22 19611 20091124 NVLS 21.13 21.25 20.73 20.96 21300 20091125 NVLS 21.02 21.2 20.93 21.06 10300 20091127 NVLS 20.4 20.93 20.28 20.72 6156 20091130 NVLS 20.77 20.8 20.4 20.69 13480 20091201 NVLS 20.84 21.34 20.86 21.28 11524 20091202 NVLS 21.28 21.79 21.22 21.74 25333 20091203 NVLS 21.8 22.5 21.63 22.35 35046 20091204 NVLS 22.98 23.44 22.73 23.36 49869 20091207 NVLS 23.34 23.635 23.31 23.52 21120 20091208 NVLS 23.41 23.9599 23.13 23.81 28519 20091209 NVLS 23.72 24.06 23.525 24.03 18202 20091210 NVLS 24.03 24.33 23.78 23.85 17509 20091211 NVLS 23.91 24.12 23.59 23.8 12876 20091214 NVLS 23.97 24.21 23.84 24.11 14186 20091215 NVLS 23.92 24.32 23.86 24.12 13214 20091216 NVLS 24.14 24.7 24.06 24.49 16742 20091217 NVLS 24.22 24.425 23.79 23.93 14684 20091218 NVLS 24.02 24.15 23.655 23.94 21004 20091221 NVLS 23.84 26 23.78 24.09 29202 20091222 NVLS 24.04 24.1 23.81 23.86 19917 20091223 NVLS 23.8 23.9199 23.5 23.56 19619 20091224 NVLS 23.58 23.6125 23.49 23.6 10032 20091228 NVLS 23.64 23.64 23.33 23.51 13430 20091229 NVLS 23.54 23.61 23.4 23.41 9227 20091230 NVLS 23.33 23.49 23.32 23.45 24282 20091231 NVLS 23.32 23.76 23.25 23.34 16627 20100104 NVLS 23.5 23.89 23.45 23.7 19723 20100105 NVLS 23.76 23.87 23.59 23.74 15063 20100106 NVLS 23.68 24.03 23.38 23.42 21068 20100107 NVLS 23.21 23.48 23.05 23.38 12860 20100108 NVLS 23.41 24.13 23.24 24.06 26343 20100111 NVLS 24.2 24.22 23.57 24.02 16844 20100112 NVLS 23.84 23.95 22.74 22.8 32847 20100113 NVLS 22.85 23.32 22.54 23.26 24208 20100114 NVLS 23.12 23.4 22.8 23.05 22681 20100115 NVLS 22.9 22.95 21.9886 22.13 36043 20100119 NVLS 22.13 22.61 21.98 22.43 20401 20100120 NVLS 22.3 22.5 22.01 22.43 21007 20100121 NVLS 22.43 22.87 22.08 22.13 23901 20100122 NVLS 21.68 21.72 20.9 20.97 46535 20100125 NVLS 21.13 21.54 20.89 21.44 37618 20100126 NVLS 21.93 22.58 21.83 22.07 79965 20100127 NVLS 22.07 22.56 21.83 22.28 39324 20100128 NVLS 22.33 22.37 21.26 21.5 44998 20100129 NVLS 21.71 21.932 20.68 20.9 36505 20100201 NVLS 20.98 21.63 20.93 21.59 30508 20100202 NVLS 21.58 22.03 21.49 21.76 28696 20100203 NVLS 21.6 22.16 21.58 22.05 45268 20100204 NVLS 21.15 21.48 20.57 21.0775 59882 20100205 NVLS 21.24 21.64 20.83 21.6 42846 20100208 NVLS 21.53 21.93 21.25 21.48 25722 20100209 NVLS 21.79 21.96 21.43 21.78 24356 20100210 NVLS 21.7 21.99 21.5 21.8 22676 20100211 NVLS 21.77 22.4 21.52 22.33 23325 20100212 NVLS 22.1 22.79 21.8 22.47 22931 20100216 NVLS 22.64 23.105 22.54 23.09 22476 20100217 NVLS 23.12 23.21 22.57 22.73 22070 20100218 NVLS 22.58 22.67 22.215 22.65 22104 20100219 NVLS 22.65 22.8 22.5 22.71 19720 20100222 NVLS 22.74 22.93 22.47 22.65 15305 20100223 NVLS 22.54 22.58 21.51 21.73 31158 20100224 NVLS 21.87 22.44 21.81 22.27 25055 20100225 NVLS 21.96 22.19 21.56 22.13 19765 20100226 NVLS 22.04 22.18 21.81 22.12 16217 20100301 NVLS 22.27 22.63 22.1 22.54 19838 20100302 NVLS 22.67 23.05 22.66 22.81 24363 20100303 NVLS 22.79 23.13 22.65 22.77 13248 20100304 NVLS 22.73 22.79 22.31 22.48 16162 20100305 NVLS 22.59 22.95 22.47 22.83 17163 20100308 NVLS 22.81 23.1 22.82 23 19270 20100309 NVLS 22.86 23.02 22.69 22.88 18733 20100310 NVLS 22.78 23.4 22.75 23.31 21850 20100311 NVLS 23.41 - ---- - -TER 10.78 10.79 10.37 10.5 49902 20100728 TER 10.37 10.5 10.05 10.21 73248 20100729 TER 11.1 11.24 10.8 11.07 226299 20100730 TER 10.84 10.88 10.53 10.76 73524 20100802 TER 11.08 11.31 10.96 11.25 75720 20100803 TER 11.2 11.2278 10.95 11.05 48837 20100804 TER 11.09 11.21 10.9 11.11 38024 20100805 TER 11.01 11.26 10.89 11.15 76524 20100806 TER 10.98 11.15 10.83 10.84 62964 20100809 TER 10.95 10.99 10.85 10.89 43971 20100810 TER 10.79 10.79 10.32 10.45 62542 20100811 TER 10.09 10.14 9.82 9.88 82657 20100812 TER 9.58 9.88 9.39 9.56 109118 20100813 TER 9.5 9.78 9.5 9.61 53050 20100816 TER 9.58 9.61 9.41 9.5 84824 20100817 TER 9.63 9.79 9.52 9.7 83035 20100819 TER 9.84 10.01 9.63 9.68 58292 20100820 TER 9.6 9.72 9.43 9.49 47867 20090821 TGT 45.6 45.87 45.13 45.66 60965 20090824 TGT 45.89 45.89 45.09 45.17 65388 20090825 TGT 45.57 46.83 45.27 46.47 110871 20090826 TGT 46.31 47.69 46.26 47.42 101865 20090827 TGT 47.29 47.55 46.81 47.29 71972 20090828 TGT 47.63 47.63 47.01 47.39 66010 20090831 TGT 47.02 47.21 46.5 47 81053 20090901 TGT 46.72 47.55 46.32 46.58 103778 20090902 TGT 46.38 46.78 45.68 46.27 80356 20090903 TGT 47.59 47.75 46.79 47.07 122391 20090904 TGT 47.17 47.36 46.87 47.12 60528 20090909 TGT 47.27 47.78 46.99 47.65 80033 20090910 TGT 47.67 48.21 47.4 48.17 68484 20090911 TGT 48.25 48.45 47.59 47.95 62097 20090914 TGT 47.69 48.04 47.32 47.42 66835 20090915 TGT 47.51 47.95 46.86 47.51 71046 20090916 TGT 47.62 48.5 47.62 48.47 65794 20090917 TGT 48.36 49.14 48.33 48.67 71467 20090918 TGT 48.84 48.93 48.48 48.79 62745 20090921 TGT 48.52 49.2 47.85 48.84 40712 20090922 TGT 48.92 48.96 48.04 48.16 69677 20090923 TGT 48.17 48.38 47.5 47.56 56197 20090924 TGT 47.63 48.04 47 47.65 53845 20090925 TGT 47.69 47.69 46.15 46.29 84146 20090928 TGT 46.57 47.83 46.35 47.71 60219 20090929 TGT 47.81 48.17 47.2 47.28 54730 20090930 TGT 46.95 47.19 46.28 46.68 93891 20091001 TGT 46.52 47.04 46 46.57 72290 20091002 TGT 46.03 46.54 45.73 46.02 60946 20091005 TGT 46.17 47.11 46.09 46.93 53983 20091006 TGT 47.59 48.18 47.59 48.09 70758 20091007 TGT 47.97 48.66 47.85 48.51 73116 20091008 TGT 47.7 49.64 47.52 49.34 120953 20091009 TGT 49.41 49.95 49.09 49.89 82513 20091012 TGT 50 50.75 49.54 49.6 72731 20091013 TGT 49.63 50.855 49.61 50.1 76764 20091014 TGT 50.92 51.77 50.3 51.35 92849 20091015 TGT 51.11 51.15 50 50.42 86297 20091016 TGT 50.27 50.33 49.65 50.08 67691 20091019 TGT 50.26 50.695 50.05 50.39 51676 20091020 TGT 50.25 50.8 49.51 49.97 43382 20091021 TGT 50.26 50.76 48.81 48.9 78832 20091022 TGT 49.01 49.95 48.82 49.49 68381 20091023 TGT 49.81 50.2 48.8 49.03 59717 20091026 TGT 49.15 50 48.62 48.88 49530 20091027 TGT 48.88 49.33 48.16 48.45 65328 20091028 TGT 49.08 49.58 48.15 48.24 95711 20091105 TGT 49.26 49.78 48.41 49.7 82774 20091106 TGT 49.6 49.97 49.15 49.7 52935 20091109 TGT 49.94 50.49 49.55 50.45 87926 20091110 TGT 50.43 50.85 49.94 50.49 48332 20091111 TGT 50.77 51.02 49.8 50.11 53039 20091112 TGT 50.12 50.39 48.7 48.93 92526 20091113 TGT 48.98 49.12 48.17 48.99 100288 20091116 TGT 49.3 50.34 49.25 50.29 109841 20091117 TGT 50.48 50.59 47.48 48.77 234946 20091118 TGT 48.25 48.26 47.72 47.87 115934 20091119 TGT 47.94 48.13 47.48 47.9 87472 20091120 TGT 47.73 48.18 47.2 47.46 77295 20091123 TGT 47.92 47.93 47.16 47.26 71771 20091124 TGT 47.1 47.55 47.05 47.46 58629 20091125 TGT 47.52 48.05 47.38 47.83 43343 20091127 TGT 46.92 47.94 46.62 47.7 42442 20091130 TGT 47.45 47.67 45.99 46.56 128686 20091201 TGT 47.075 47.25 46.643 46.78 95429 20091202 TGT 46.75 47.79 46.67 47.72 112673 20091203 TGT 47.08 47.25 46.05 46.35 143680 20091204 TGT 46.9 47.19 45.17 45.64 175116 20091207 TGT 45.64 46.5 45.64 46.34 86425 20091208 TGT 46.2 46.2 45.42 45.87 63704 20091209 TGT 45.7 45.73 45.11 45.3 66434 20091210 TGT 45.66 46.17 45.17 45.99 77462 20091211 TGT 46.17 47.02 46.07 46.93 75531 20091214 TGT 47.21 47.91 46.915 47.84 89795 20091215 TGT 47.76 47.9 47.37 47.66 70233 20091216 TGT 47.88 48 47.46 47.48 53659 20091217 TGT 47.34 47.94 47.1 47.5 - ---- - -14.78 15.06 39829 20100203 SVU 15 15.02 14.65 14.73 34319 20100204 SVU 14.62 14.83 14.41 14.44 44919 20100205 SVU 14.39 14.6 14.3 14.59 38565 20100208 SVU 14.61 14.635 14.32 14.42 26670 20100209 SVU 14.56 14.855 14.49 14.8 36052 20100210 SVU 14.76 14.98 14.59 14.82 29467 20100211 SVU 14.77 14.965 14.58 14.91 25995 20100212 SVU 14.82 14.93 14.55 14.77 39867 20100216 SVU 14.83 15.23 14.72 15.2 37648 20100217 SVU 15.2 15.48 15.14 15.44 31622 20100218 SVU 15.33 15.84 15.33 15.72 32338 20100219 SVU 15.7 15.88 15.53 15.79 30517 20100222 SVU 15.75 15.87 15.67 15.68 13380 20100223 SVU 15.64 15.64 15.22 15.29 30150 20100224 SVU 15.35 15.38 15.19 15.27 34167 20100225 SVU 14.94 15.29 14.79 15.26 46714 20100226 SVU 15.29 15.32 15.05 15.27 37861 20100301 SVU 15.29 15.69 15.27 15.65 26473 20100302 SVU 15.71 15.99 15.63 15.88 36556 20100303 SVU 15.77 15.965 15.55 15.71 39995 20100304 SVU 15.71 16 15.57 15.99 32701 20100305 SVU 16 16.04 15.8 15.86 38250 20100308 SVU 15.89 16.16 15.79 16.15 25231 20100309 SVU 16.2 16.5 16.01 16.16 50442 20100310 SVU 16.19 16.28 15.96 16.09 32797 20100311 SVU 16.04 16.07 15.75 16.07 22747 20100312 SVU 16.06 17.89 15.86 17.13 181447 20100315 SVU 17.02 17.71 16.77 17.37 52422 20100316 SVU 17.37 17.51 17.2 17.33 30381 20100317 SVU 17.29 17.6 17.25 17.47 27149 20100318 SVU 17.41 17.46 17.07 17.14 29966 20100319 SVU 17.06 17.08 16.54 16.73 54520 20100322 SVU 16.61 16.86 16.26 16.75 38005 20100323 SVU 16.72 16.91 16.52 16.91 21829 20100324 SVU 16.81 16.86 16.43 16.59 27599 20100325 SVU 16.76 16.76 16.46 16.49 30288 20100326 SVU 16.52 16.57 16.15 16.22 24912 20100329 SVU 16.41 16.42 16.24 16.31 22630 20100330 SVU 16.38 16.92 16.27 16.8 57848 20100331 SVU 16.8 16.8 16.63 16.68 26161 20100401 SVU 16.79 16.89 16.64 16.77 20968 20100405 SVU 16.85 16.99 16.74 16.9 23779 20100406 SVU 16.82 16.86 16.745 16.82 26570 20100407 SVU 16.73 16.87 16.5 16.58 38598 20100408 SVU 16.56 16.56 16.24 16.42 33629 20100409 SVU 16.38 16.6 16.28 16.4 32615 20100412 SVU 16.55 17 16.51 16.83 36090 20100413 SVU 16.82 16.95 16.67 16.89 19125 20100414 SVU 16.9 16.93 16.52 16.84 31962 20100415 SVU 16.78 17.21 16.66 17.16 40345 20100416 SVU 17.36 17.44 16.83 16.98 62706 20100419 SVU 17 17.31 16.85 17.14 52141 20100420 SVU 16.51 17.47 16.04 16.27 109638 20100421 SVU 16.25 16.42 15.96 16.29 57804 20100422 SVU 16.14 16.26 15.99 16.09 36478 20100423 SVU 16.16 16.16 15.76 16 37069 20100426 SVU 15.88 16 15.27 15.36 64726 20100427 SVU 15.23 15.3 14.9 14.96 59777 20100428 SVU 15.05 15.225 14.93 14.99 45830 20100429 SVU 15.08 15.29 14.76 15.17 43139 20100430 SVU 15.12 15.25 14.78 14.9 41400 20100503 SVU 14.98 15.18 14.85 15.08 35072 20100504 SVU 14.92 15.04 14.72 14.77 39282 20100505 SVU 14.69 15.15 14.6 15 38108 20100506 SVU 14.93 14.95 13.19 13.99 79797 20100507 SVU 13.97 14.09 13.34 13.4 79470 20100510 SVU 13.99 14.08 13.56 13.76 50606 20100511 SVU 13.63 14.18 13.58 13.86 36799 20100512 SVU 13.87 14.13 13.79 14.1 32452 20100513 SVU 14.1 14.24 13.8 13.83 38704 20100514 SVU 13.83 13.85 13.55 13.64 28929 20100517 SVU 13.59 13.79 13.26 13.75 40862 20100518 SVU 13.9 14.05 13.7 13.72 27665 20100519 SVU 13.63 13.91 13.55 13.72 34152 20100520 SVU 13.45 13.45 12.86 12.86 46574 20100521 SVU 12.82 13.269 12.65 13.23 51135 20100524 SVU 12.99 13.24 12.99 13.15 39308 20100525 SVU 12.72 13.32 12.5 13.24 61137 20100526 SVU 13.54 13.775 13.38 13.44 47323 20100527 SVU 13.47 13.66 13.27 13.61 33389 20100528 SVU 13.67 13.91 13.4 13.47 32111 20100601 SVU 13.31 13.46 13 13 34254 20100602 SVU 13.06 13.24 12.83 13.05 38294 20100603 SVU 13.12 13.27 12.895 13.05 28932 20100604 SVU 12.81 12.99 12.65 12.68 32328 20100607 SVU 12.63 12.72 12.22 12.34 41640 20100608 SVU 12.33 12.34 11.95 12.17 41289 20100609 SVU 12.2 12.43 11.93 11.99 35742 20100610 SVU 12.16 12.5 12.16 12.49 29650 20100611 SVU 12.43 12.43 12.17 12.24 30059 20100614 SVU 12.33 12.49 12.21 12.36 24366 20100615 SVU 12.51 12.83 12.37 12.76 25920 20100616 SVU 12.67 12.94 12.46 12.48 40824 20100617 SVU 12.76 13.26 12.73 - ---- - -ESRX 90.6 91.07 87.24 88.83 28801 20100121 ESRX 88.43 88.71 85.57 86.33 26789 20100122 ESRX 86.06 87.41 85.07 85.2 32635 20100125 ESRX 85.51 86.495 85.2 85.81 16620 20100126 ESRX 85.56 85.93 84.9 85.2 15413 20100127 ESRX 84.86 85.98 84.15 85.6 17227 20100128 ESRX 85.63 86.46 84.46 84.9 17160 20100129 ESRX 85.45 85.64 83.86 83.86 20230 20100201 ESRX 84.03 85.56 83.16 85.56 19174 20100202 ESRX 85.25 87.1 84.76 87.03 17461 20100203 ESRX 86.09 86.67 85.31 86.44 16257 20100204 ESRX 85.94 85.94 84.32 84.32 24721 20100205 ESRX 84.62 85.31 82.76 84.82 32830 20100208 ESRX 85.07 85.39 84.17 84.5 16203 20100209 ESRX 85.39 86.12 84.22 85.24 15291 20100210 ESRX 85 85.86 84.41 84.97 15533 20100211 ESRX 84.93 87.22 84.71 86.76 21124 20100212 ESRX 85.94 86.54 85.43 86.43 16092 20100216 ESRX 86.955 87.45 85.7 87.3 11884 20100217 ESRX 87.89 89.48 87.2765 88.8 16630 20100218 ESRX 89.04 90.11 88.81 89.75 16079 20100219 ESRX 89.65 90.39 89.27 90.12 20416 20100222 ESRX 90.34 90.944 89.13 89.37 24038 20100223 ESRX 88.89 88.915 87.33 87.99 23010 20100224 ESRX 88.32 89.2 87.43 87.75 35694 20100225 ESRX 96.32 96.66 93.65 95.23 82902 20100226 ESRX 95.19 96.42 94.5 96.01 24253 20100301 ESRX 95.03 97.19 95 96.44 25281 20100302 ESRX 96.84 98.79 96.36 98.67 32154 20100303 ESRX 98.69 99.45 98.311 98.99 29149 20100304 ESRX 98.64 99.58 98.37 99.02 28499 20100305 ESRX 98.63 99.51 98.49 99.445 26148 20100308 ESRX 98.6 99.45 98.02 98.29 18110 20100309 ESRX 97.94 99.04 97.78 98.33 14493 20100310 ESRX 97.99 99.06 97.97 98.59 12391 20100311 ESRX 98.57 99.25 97.74 99.25 15884 20100312 ESRX 99.84 99.95 98.57 98.94 15323 20100315 ESRX 98.91 99.91 98.4215 99.9 21648 20100316 ESRX 100 100.5 98.58 99.67 14379 20100317 ESRX 99.57 100 98.23 99.01 13036 20100318 ESRX 98.79 99.64 98.3701 99.64 15347 20100319 ESRX 101.08 101.11 99.5 100.73 28481 20100322 ESRX 101.4 103.24 101.26 102.18 25439 20100323 ESRX 102.54 102.73 101.31 102 21926 20100324 ESRX 101.99 102.29 100.81 100.83 12615 20100325 ESRX 101.68 101.7 100.11 100.58 15583 20100326 ESRX 100.78 101.31 99.575 100.62 14866 20100329 ESRX 100.84 102.4 100.58 102.24 13829 20100330 ESRX 102.04 102.5 100.95 101.6 10356 20100331 ESRX 101.25 102.1 100.39 101.76 11203 20100401 ESRX 102.36 103 101.43 102.39 12645 20100405 ESRX 102.75 102.99 102.02 102.4 8347 20100406 ESRX 101.77 102.75 101.72 102.06 8696 20100407 ESRX 102.25 102.57 101.175 101.68 12759 20100408 ESRX 101.51 103.53 100.95 103.06 18408 20100409 ESRX 103.21 103.8 102.7 103.31 13921 20100412 ESRX 103.26 103.37 101.82 102.43 13235 20100413 ESRX 102.05 103.09 100.31 102.94 19532 20100414 ESRX 102.95 103.31 99.81 100.54 32484 20100415 ESRX 100.4 101.04 98.23 98.89 31134 20100416 ESRX 99.03 100.96 98.64 100.78 27784 20100419 ESRX 100.69 103.07 100.13 102.79 22872 20100420 ESRX 103.25 105 102.25 104.91 19466 20100421 ESRX 104.42 104.87 102.94 103.67 19219 20100422 ESRX 103.51 103.8 102.29 103.1 13636 20100423 ESRX 103.09 104.24 102.39 104.19 14652 20100426 ESRX 103.79 104.69 102.34 102.75 13640 20100427 ESRX 103.43 105 102.3 102.3 25463 20100428 ESRX 103.27 103.71 100.06 101.68 33725 20100429 ESRX 99.45 104.13 99.32 102.89 42047 20100430 ESRX 102.41 103.27 99.79 100.13 26235 20100503 ESRX 100.1 101.23 98.26 100.46 24023 20100504 ESRX 99.12 101.24 98.65 99.94 27019 20100505 ESRX 99.87 103.18 99.98 102.49 24813 20100506 ESRX 102.58 104.25 75.5 99.6 53326 20100507 ESRX 99.31 99.89 96.31 97.15 41659 20100510 ESRX 100.82 104.42 99.72 104.37 40675 20100511 ESRX 102.93 104.37 102.68 103.17 32703 20100512 ESRX 103.5 105.07 102.4 104.13 22860 20100513 ESRX 103.84 104.66 102.73 103.66 21568 20100514 ESRX 103.43 103.75 100.84 101.69 29054 20100517 ESRX 102.2 103.76 101.7 103.12 23495 20100518 ESRX 102.95 106.3 102.53 104.13 31714 20100519 ESRX 104.1 104.93 103.08 103.77 30056 20100520 ESRX 101.555 102.2 99.31 99.51 36975 20100521 ESRX 97.75 101.54 97.51 100.59 38947 20100524 ESRX 100 101.54 98.66 100.32 22700 20100525 ESRX 98.44 99.89 97.55 99.13 29789 20100526 ESRX 98.99 101.58 98.42 - ---- - -IP 26.19 26.19 24.81 25.01 111810 20100505 IP 24.6 25.45 24.3 24.76 79523 20100506 IP 24.55 25.16 20.5 23.34 152968 20100507 IP 22.23 23.8 21.53 23.16 151037 20100510 IP 25.01 25.45 24.22 24.79 80144 20100511 IP 24.49 24.88 24.11 24.29 57643 20100512 IP 24.47 24.96 24.33 24.93 60708 20100513 IP 24.72 24.92 24.22 24.31 56798 20100514 IP 23.96 24.04 23.46 23.78 88910 20100517 IP 23.92 24.37 23.03 23.6 92272 20100518 IP 23.97 24.33 22.87 22.93 63032 20100519 IP 22.66 22.84 21.72 22.52 101373 20100520 IP 21.68 22.3 21.23 21.76 139729 20100521 IP 21.18 22.715 21.09 22.28 100026 20100524 IP 22.13 22.53 21.74 21.75 62640 20100525 IP 20.94 22.26 20.77 22.23 93577 20100526 IP 22.58 23.25 22.06 22.34 74161 20100527 IP 23.04 23.77 22.735 23.76 75154 20100528 IP 23.7 23.83 23 23.23 59553 20100601 IP 22.82 23.35 22.23 22.24 55603 20100602 IP 22.34 22.99 22.25 22.97 57310 20100603 IP 23.09 23.68 22.84 23.39 71894 20100604 IP 22.74 23.12 21.86 21.93 79610 20100607 IP 22.01 22.06 21.05 21.08 104412 20100608 IP 21.07 21.72 21.04 21.64 87785 20100609 IP 21.9 22.69 21.75 21.87 73330 20100610 IP 22.34 23.03 22.34 23.02 58326 20100611 IP 23.29 24.37 23.02 24.3 92418 20100614 IP 24.71 25.7 24.67 25.05 127536 20100615 IP 25.4 26.23 25.08 26.2 96960 20100616 IP 25.83 26.04 25.48 25.66 63937 20100617 IP 25.8 25.85 25.055 25.52 64414 20100618 IP 25.64 25.92 25.48 25.73 64886 20100621 IP 26.48 26.97 26.16 26.31 75897 20100622 IP 26.26 26.57 24.26 24.35 110304 20100623 IP 24.26 25.27 23.98 25.2 108442 20100624 IP 25.05 25.155 23.61 23.72 93955 20100625 IP 23.79 24.64 23.54 24.59 167774 20100628 IP 24.48 24.72 23.79 23.99 68957 20100629 IP 23.37 23.46 22.18 22.39 118859 20100630 IP 22.38 23.29 22.3 22.63 104325 20100701 IP 22.75 23.18 21.96 22.94 94779 20100702 IP 23.15 23.33 22.25 22.59 63090 20100706 IP 23.22 23.34 22.04 22.33 57045 20100707 IP 22.23 23.14 22.23 23.13 63684 20100708 IP 23.28 23.4962 22.73 23.15 82415 20100709 IP 23.1 23.86 23.1 23.67 50069 20100712 IP 23.7 23.81 23.09 23.32 62081 20100713 IP 23.79 24.41 23.71 24.14 64604 20100714 IP 24.11 24.12 23.43 23.79 63058 20100715 IP 23.81 23.81 22.97 23.59 53369 20100716 IP 23.44 23.57 22.71 22.78 65073 20100719 IP 23 23.17 22.4 23.06 55045 20100720 IP 22.74 24.28 22.49 24.28 74028 20100721 IP 24.53 24.65 23.33 23.49 60497 20100722 IP 23.84 24.75 23.76 24.59 56775 20100723 IP 24.56 25.06 24.36 24.98 54742 20100726 IP 25.16 25.52 24.82 25.5 54617 20100727 IP 25.76 25.79 25 25.49 70485 20100728 IP 24.62 24.85 23.44 24.12 131894 20100729 IP 24.42 24.787 23.82 24.09 85452 20100730 IP 23.75 24.34 23.63 24.2 48365 20100802 IP 24.71 25.28 24.56 25.18 62694 20100803 IP 24.8 25 24.385 24.51 52540 20100804 IP 24.75 24.88 24.28 24.54 38148 20100805 IP 24.39 24.83 24.3 24.63 46446 20100806 IP 24.35 24.67 23.49 24.06 66788 20100809 IP 24.28 24.46 23.66 23.69 51098 20100810 IP 23.45 23.49 22.65 22.91 90756 20100811 IP 22.51 22.54 21.84 21.87 67713 20100812 IP 21.45 22.14 21.18 21.87 61139 20100813 IP 21.75 22.16 21.67 21.87 43635 20100816 IP 21.72 22.22 21.42 21.59 80492 20100817 IP 21.97 22.22 21.65 21.99 62589 20100819 IP 21.65 21.82 21.11 21.28 53084 20100820 IP 21.03 21.42 20.95 21.21 47184 20090821 IPG 6.16 6.72 6.16 6.47 79450 20090824 IPG 6.48 6.58 6.38 6.44 64236 20090825 IPG 6.49 6.61 6.36 6.56 46042 20090826 IPG 6.57 6.6 6.29 6.4 68224 20090827 IPG 6.43 6.54 6.16 6.52 52959 20090828 IPG 6.6 6.64 6.29 6.42 54489 20090831 IPG 6.31 6.42 6.1799 6.29 45113 20090901 IPG 6.23 6.54 6.14 6.15 73594 20090902 IPG 6.22 6.22 5.87 6.01 76939 20090903 IPG 6.04 6.08 5.94 5.99 53393 20090904 IPG 6.01 6.19 6.01 6.18 48811 20090909 IPG 6.42 6.68 6.27 6.66 71326 20090910 IPG 6.68 6.84 6.55 6.82 47459 20090911 IPG 6.76 6.87 6.65 6.75 42393 20090914 IPG 6.68 6.78 6.53 6.59 56535 20090915 IPG 6.7 7.29 6.48 7.18 133990 20090916 IPG 7.24 7.37 7.04 7.36 89323 20090917 IPG 7.32 7.39 7.12 7.28 66142 20090918 IPG 7.35 7.56 7.35 7.47 60774 20090921 IPG 7.4 7.49 7.13 7.4 62907 20090922 IPG 7.18 7.45 7.16 7.2 51463 20090923 IPG - ---- - -FIS 22.56 22.78 22.41 22.61 37029 20100219 FIS 22.48 22.79 22.42 22.68 28900 20100222 FIS 22.71 22.84 22.6 22.65 18346 20100223 FIS 22.65 22.81 22.45 22.6 26523 20100224 FIS 22.68 22.92 22.445 22.88 33282 20100225 FIS 22.61 22.83 22.52 22.8 42534 20100226 FIS 22.78 22.78 22.5 22.54 49756 20100301 FIS 22.56 23.07 22.54 23.07 19697 20100302 FIS 23 23.2 22.93 22.98 17841 20100303 FIS 22.98 23.18 22.86 22.93 18112 20100304 FIS 22.99 23.05 22.84 23.03 14635 20100305 FIS 23.11 23.5 22.98 23.48 17961 20100308 FIS 23.45 23.51 23.32 23.4 14906 20100309 FIS 23.25 23.34 23.08 23.14 40134 20100310 FIS 23.1 23.18 22.95 23.18 27856 20100311 FIS 23.24 23.3 23.09 23.2 23490 20100312 FIS 23.16 23.2 23.02 23.19 15581 20100315 FIS 23.15 23.39 23.04 23.35 17276 20100316 FIS 23.33 23.53 23.28 23.52 18515 20100317 FIS 23.51 23.99 23.48 23.83 29083 20100318 FIS 23.74 23.83 23.5 23.57 20862 20100319 FIS 23.63 23.75 23.48 23.63 34318 20100322 FIS 23.57 23.85 23.49 23.71 14876 20100323 FIS 23.78 23.83 23.59 23.77 10744 20100324 FIS 23.75 23.75 23.56 23.59 12198 20100325 FIS 23.67 23.78 23.38 23.39 18051 20100326 FIS 23.38 23.76 23.31 23.66 20871 20100329 FIS 23.79 23.82 23.46 23.57 20572 20100330 FIS 23.58 23.63 23.31 23.43 18124 20100331 FIS 23.33 23.47 23.25 23.44 19412 20100401 FIS 23.5 23.78 23.48 23.69 22200 20100405 FIS 23.72 23.86 23.66 23.82 11654 20100406 FIS 23.73 23.98 23.655 23.9 17859 20100407 FIS 23.82 24.27 23.75 24.21 46757 20100408 FIS 24.11 24.4 23.94 24.32 32384 20100409 FIS 24.3 24.55 24.22 24.52 16857 20100412 FIS 24.65 24.91 24.65 24.79 17115 20100413 FIS 24.79 24.92 24.53 24.67 19134 20100414 FIS 24.59 24.94 24.59 24.86 30639 20100415 FIS 24.77 25.38 24.7 25.35 23347 20100416 FIS 25.24 25.55 25.13 25.19 31267 20100419 FIS 25.1 25.19 24.9 25.16 18867 20100420 FIS 25.36 25.72 25.22 25.63 26860 20100421 FIS 25.52 25.82 25.4 25.57 20011 20100422 FIS 25.34 25.8 25.21 25.75 17210 20100423 FIS 25.79 25.88 25.26 25.76 29725 20100426 FIS 25.71 25.9 25.62 25.65 23394 20100427 FIS 25.54 25.78 25.03 25.04 27631 20100428 FIS 25.34 26.6 25.24 26.34 58522 20100429 FIS 26.45 26.74 26.26 26.73 38123 20100430 FIS 26.7 26.75 26.18 26.29 35730 20100503 FIS 26.35 26.52 26.19 26.3 28527 20100504 FIS 26.04 26.19 25.8 25.96 44225 20100505 FIS 25.86 26.11 25.84 26 28374 20100506 FIS 25.9 30.78 25.745 28.68 359786 20100507 FIS 28.53 29.22 28.28 28.76 156152 20100510 FIS 29.51 29.79 29.2 29.63 89160 20100511 FIS 29.01 29.52 28.83 28.86 55441 20100512 FIS 30.13 30.3299 29.63 29.7 147943 20100513 FIS 29.87 30.27 29.76 29.9 86569 20100514 FIS 29.83 29.99 28.35 29.69 80658 20100517 FIS 29.73 29.8 28.7 28.88 66074 20100518 FIS 27.11 27.78 26.8 27.15 179621 20100519 FIS 27.06 27.56 26.94 27.01 79987 20100520 FIS 26.75 26.8 25.5 25.81 124838 20100521 FIS 25.51 26.27 25.44 26.17 85528 20100524 FIS 26.11 26.36 25.62 26.12 53373 20100525 FIS 25.77 26.56 25.28 26.56 97838 20100526 FIS 28.14 28.23 27.36 27.47 153752 20100527 FIS 27.87 27.98 27.67 27.95 62760 20100528 FIS 27.9 27.92 27.5 27.52 37480 20100601 FIS 27.4 27.6 27.26 27.3 46811 20100602 FIS 27.42 27.58 27.16 27.56 38165 20100603 FIS 27.47 27.74 27.42 27.48 29941 20100604 FIS 27.49 27.56 27.05 27.14 61845 20100607 FIS 27.15 27.28 26.71 26.75 50496 20100608 FIS 26.74 26.98 26.48 26.88 43822 20100609 FIS 27.03 27.28 26.63 26.74 55217 20100610 FIS 26.96 27.4 26.96 27.3 33115 20100611 FIS 27.17 27.26 26.99 27.21 26311 20100614 FIS 27.41 27.46 26.97 27.04 31288 20100615 FIS 27.17 27.39 27.03 27.27 41741 20100616 FIS 27.15 27.84 27.12 27.64 60314 20100617 FIS 27.73 27.8 27.54 27.79 32339 20100618 FIS 27.84 27.85 27.47 27.48 39451 20100621 FIS 27.76 27.925 27.52 27.64 44119 20100622 FIS 27.83 28.04 27.25 27.27 31866 20100623 FIS 27.27 27.48 27.1 27.26 30393 20100624 FIS 27.17 27.43 26.98 27.14 23598 20100625 FIS 27.7 27.8 27.31 27.54 57561 20100628 FIS 27.51 27.75 27.26 27.4 18080 20100629 FIS 27.18 27.29 26.91 27.05 45236 20100630 FIS 27.01 27.35 26.78 26.82 34760 20100701 FIS 27.01 27.05 26.45 26.53 59679 20100702 - ---- - -195358 20100128 TXN 23.46 23.51 22.69 23.05 202002 20100129 TXN 23.11 23.37 22.28 22.5 231372 20100201 TXN 22.56 23.08 22.56 23.05 131989 20100202 TXN 22.97 23.37 22.94 23.31 118910 20100203 TXN 23.26 23.32 22.93 23.2 128825 20100204 TXN 23.01 23.01 22.4 22.59 146440 20100205 TXN 22.55 23.13 22.5 22.97 230939 20100208 TXN 23 23.37 22.7 23.1 161392 20100209 TXN 23.33 23.66 23.27 23.38 174955 20100210 TXN 23.39 23.58 23.141 23.44 124013 20100211 TXN 23.43 24 23.3 23.77 161971 20100212 TXN 23.54 24.27 23.4 24.03 217975 20100216 TXN 24.13 24.88 24.13 24.79 228568 20100217 TXN 24.86 24.97 24.3 24.71 194304 20100218 TXN 24.65 24.86 24.385 24.83 132190 20100219 TXN 24.8 25.06 24.59 25.01 159789 20100222 TXN 25.02 25.15 24.62 24.73 111767 20100223 TXN 24.68 24.72 24.06 24.3 129057 20100224 TXN 24.53 25 24.48 24.75 145146 20100225 TXN 24.21 24.55 24.01 24.52 178860 20100226 TXN 24.45 24.61 24.2275 24.38 132059 20100301 TXN 24.53 24.925 24.47 24.63 148938 20100302 TXN 24.54 24.92 24.25 24.48 168885 20100303 TXN 24.57 24.79 24.35 24.4 130126 20100304 TXN 24.46 24.75 24.16 24.67 135379 20100305 TXN 24.8 25.09 24.6075 24.97 103485 20100308 TXN 25.09 25.09 24.55 24.69 222691 20100309 TXN 24.29 24.49 23.87 24.19 279905 20100310 TXN 24.19 24.68 24.17 24.59 138785 20100311 TXN 24.38 24.4 23.8 24.07 230882 20100312 TXN 24.1 24.24 23.9 24 150738 20100315 TXN 23.91 23.99 23.7 23.94 90533 20100316 TXN 24.01 24.75 23.96 24.68 182819 20100317 TXN 24.56 25 24.56 24.91 126211 20100318 TXN 24.89 25 24.55 24.72 105019 20100319 TXN 24.72 24.73 24.13 24.36 169453 20100322 TXN 24.22 24.75 24.17 24.73 106521 20100323 TXN 24.8 25.48 24.73 25.45 179378 20100324 TXN 25.31 25.33 24.72 24.79 169292 20100325 TXN 25.16 25.22 24.78 24.79 113064 20100326 TXN 24.91 25.03 24.51 24.75 101379 20100329 TXN 24.86 25.07 24.62 24.73 92175 20100330 TXN 24.73 24.89 24.5 24.61 110744 20100331 TXN 24.58 24.7725 24.38 24.47 98998 20100401 TXN 24.64 25 24.44 24.63 90569 20100405 TXN 24.7 25.5 24.66 25.39 142257 20100406 TXN 25.25 25.3 24.93 25.05 106280 20100407 TXN 25.11 25.4 24.89 25.32 133339 20100408 TXN 25.12 25.32 24.72 24.72 160034 20100409 TXN 24.87 24.97 24.62 24.94 134514 20100412 TXN 25.26 25.98 25.24 25.69 185745 20100413 TXN 25.63 26 25.58 25.87 116066 20100414 TXN 26.41 26.91 26.38 26.9 203173 20100415 TXN 26.87 27 26.6 26.99 115712 20100416 TXN 26.73 26.81 26.35 26.58 147765 20100419 TXN 26.47 26.68 25.91 26.43 132896 20100420 TXN 26.6 26.84 26.4 26.65 110046 20100421 TXN 26.82 26.9 26.06 26.42 104803 20100422 TXN 25.95 26.6 25.4 26.5 175064 20100423 TXN 26.47 26.75 26.03 26.67 144715 20100426 TXN 26.83 27.35 26.79 27.16 210703 20100427 TXN 26.8 27.44 26.41 26.54 376491 20100428 TXN 26.74 26.76 26.0901 26.4 171882 20100429 TXN 26.635 27.05 26.36 27.01 151334 20100430 TXN 26.91 26.95 26.01 26.01 180689 20100503 TXN 26.23 26.72 26.1 26.45 129850 20100504 TXN 26.18 26.22 25.44 25.74 210862 20100505 TXN 25.53 26.18 25.191 25.87 214855 20100506 TXN 25.78 26.12 23.49 25.07 273766 20100507 TXN 24.91 25.27 23.96 24.74 264918 20100510 TXN 25.68 26 25.45 25.82 176226 20100511 TXN 25.5 26.15 25.25 25.65 158929 20100512 TXN 25.81 26.15 25.67 26.1 126989 20100513 TXN 25.98 26.09 25.41 25.49 133141 20100514 TXN 25.27 25.36 24.5 24.88 183232 20100517 TXN 24.95 25.5 24.66 25.42 164559 20100518 TXN 25.6 25.66 24.39 24.54 250473 20100519 TXN 24.43 24.87 24.1 24.65 194045 20100520 TXN 24.14 24.7 23.9 24.26 245637 20100521 TXN 23.89 24.84 23.6 24.57 192649 20100524 TXN 24.45 24.6 24.15 24.24 126525 20100525 TXN 23.62 24.44 23.45 24.4 207615 20100526 TXN 24.54 24.8201 24.04 24.14 179781 20100527 TXN 24.51 24.87 24.46 24.85 149743 20100528 TXN 24.77 24.9 24.2 24.42 145900 20100601 TXN 24.28 24.86 24.27 24.35 150996 20100602 TXN 24.52 24.78 24.238 24.76 128460 20100603 TXN 24.81 25.18 24.645 25.04 121507 20100604 TXN 24.66 24.95 24.07 24.1775 145425 20100607 TXN 24.32 24.56 23.605 23.67 168834 20100608 TXN 23.99 24 23.09 23.88 191134 20100609 TXN 24.3 24.54 23.64 23.74 198828 20100610 - ---- - -20100602 PFE 15.12 15.22 14.92 15.2 495486 20100603 PFE 15.24 15.34 15.12 15.2325 342474 20100604 PFE 15.01 15.04 14.67 14.755 779382 20100607 PFE 14.86 14.89 14.5 14.52 687857 20100608 PFE 14.56 14.57 14.35 14.55 632462 20100609 PFE 14.64 14.75 14.39 14.52 865832 20100610 PFE 14.65 15.11 14.65 14.91 601769 20100611 PFE 15.23 15.52 15.2 15.46 756211 20100614 PFE 15.56 15.6 15.3 15.33 512611 20100615 PFE 15.4 15.53 15.3 15.52 504777 20100616 PFE 15.42 15.57 15.36 15.48 379236 20100617 PFE 15.43 15.47 15.13 15.47 497231 20100618 PFE 15.49 15.55 15.0875 15.21 698247 20100621 PFE 15.36 15.38 15.01 15.1 457157 20100622 PFE 15.155 15.24 14.97 14.97 438489 20100623 PFE 14.98 14.98 14.81 14.88 483207 20100624 PFE 14.62 14.73 14.37 14.46 860758 20100625 PFE 14.49 14.71 14.4 14.64 586342 20100628 PFE 14.69 14.775 14.5 14.54 446228 20100629 PFE 14.42 14.48 14.18 14.28 648926 20100630 PFE 14.215 14.48 14.17 14.26 506833 20100701 PFE 14.29 14.33 14 14.23 678767 20100702 PFE 14.29 14.36 14.1 14.14 407539 20100706 PFE 14.33 14.41 14.1425 14.29 719526 20100707 PFE 14.31 14.63 14.2 14.62 542619 20100708 PFE 14.78 14.98 14.62 14.82 597926 20100709 PFE 14.85 14.86 14.63 14.77 326207 20100712 PFE 14.73 14.94 14.69 14.93 383671 20100713 PFE 15 15.1 14.76 14.79 500494 20100714 PFE 14.73 14.96 14.65 14.84 455868 20100715 PFE 14.85 14.93 14.65 14.87 436262 20100716 PFE 14.83 14.94 14.55 14.56 477874 20100719 PFE 14.62 14.84 14.58 14.73 327077 20100720 PFE 14.65 14.65 14.44 14.55 471419 20100721 PFE 14.52 14.72 14.42 14.5 422883 20100722 PFE 14.61 14.87 14.59 14.81 448142 20100723 PFE 14.75 14.8 14.39 14.58 532024 20100726 PFE 14.63 15.09 14.61 15.02 554948 20100727 PFE 15.08 15.36 14.99 15.27 606620 20100728 PFE 15.28 15.44 14.95 15 403540 20100729 PFE 15.175 15.42 15.02 15.09 585268 20100730 PFE 15.02 15.13 14.88 15 440411 20100802 PFE 15.16 15.48 15.1 15.48 547880 20100803 PFE 16 16.48 15.95 16.34 1592053 20100804 PFE 16.26 16.52 16.1175 16.44 731704 20100805 PFE 16.39 16.48 16.07 16.19 737300 20100806 PFE 16.06 16.28 16 16.24 516321 20100809 PFE 16.29 16.48 16.1063 16.42 480861 20100810 PFE 16.29 16.6 16.26 16.57 575932 20100811 PFE 16.3 16.34 15.99 16 537146 20100812 PFE 15.9 16.23 15.86 16.2 484531 20100813 PFE 16.16 16.25 16.03 16.08 324062 20100816 PFE 15.98 16.17 15.85 16.03 362828 20100817 PFE 16.23 16.4 16.1304 16.27 504657 20100819 PFE 16.07 16.13 15.82 16.03 532621 20100820 PFE 15.91 16.015 15.85 15.92 490995 20090821 PFG 26.3 28.13 26.12 27.74 47727 20090824 PFG 28.12 28.69 27.65 27.85 50478 20090825 PFG 28.11 28.86 27.93 28.04 34908 20090826 PFG 28.04 28.33 27.48 28.1 30747 20090827 PFG 27.68 28.87 27.38 28.71 31923 20090828 PFG 29.11 29.41 28.31 28.88 21923 20090831 PFG 28.35 28.47 27.85 28.4 24323 20090901 PFG 27.95 28.36 25.95 26.16 42524 20090902 PFG 25.93 26.23 25.3 25.93 44565 20090903 PFG 25.89 26.42 25.28 25.77 44533 20090904 PFG 25.79 26.27 25.56 26.06 23538 20090909 PFG 26.33 26.73 26.19 26.63 24968 20090910 PFG 26.7 28.56 26.5 28.49 41515 20090911 PFG 27.91 28.3 27.55 27.83 52971 20090914 PFG 27.36 28.03 27.07 28 31701 20090915 PFG 28.2 28.46 27.78 28.2 28410 20090916 PFG 28.4 30.87 28.2 30.83 50226 20090917 PFG 30.19 30.75 28.83 29.01 38943 20090918 PFG 29.18 29.3 28.14 28.29 42943 20090921 PFG 27.44 27.93 27.29 27.56 33078 20090922 PFG 28.03 28.29 27.5 27.76 39663 20090923 PFG 28.01 28.01 26.35 26.36 49439 20090924 PFG 26.58 26.9 25.81 26.03 32463 20090925 PFG 25.9 26.09 25.16 25.8 33777 20090928 PFG 25.92 27.99 25.75 27.97 40614 20090929 PFG 27.95 28.53 27.37 27.83 28275 20090930 PFG 27.84 28.39 26.86 27.39 35961 20091001 PFG 27.2 27.3 25.4 25.46 47228 20091002 PFG 25.11 25.81 24.3801 25.26 41000 20091005 PFG 25.51 26.68 25.3 26.64 30377 20091006 PFG 26.91 27.88 26.43 27.26 46957 20091007 PFG 27.14 27.58 26.86 27.4 26613 20091008 PFG 27.68 28.33 27.5 28.11 41339 20091009 PFG 27.87 28.37 27.69 28.29 25501 20091012 PFG 28.48 28.58 28.16 28.51 19649 20091013 PFG 28.21 28.4 27.43 27.81 21681 20091014 PFG 28.51 29.64 28.29 - ---- - -20.03 19.25 19.92 37648 20100301 TXT 20 20.31 19.82 20.21 44004 20100302 TXT 20.34 20.99 20.05 20.9 49482 20100303 TXT 20.92 21.45 20.76 21.24 46268 20100304 TXT 21.36 21.57 20.93 21.06 50492 20100305 TXT 21.2 21.84 21.2 21.81 45740 20100308 TXT 21.78 22.17 21.73 21.74 43337 20100309 TXT 21.13 21.96 21.01 21.62 78018 20100310 TXT 21.17 22.07 21.17 21.81 47187 20100311 TXT 21.68 22.34 21.3 22.25 39057 20100312 TXT 22.37 22.44 21.92 22.26 33746 20100315 TXT 22.17 22.2 21.61 22.05 30485 20100316 TXT 22.06 22.78 21.94 22.4 43861 20100317 TXT 22.52 22.78 22.23 22.53 30612 20100318 TXT 22.41 22.5 22 22.15 26976 20100319 TXT 22.21 22.97 22.07 22.21 56745 20100322 TXT 21.99 22.4 21.8 22.18 30576 20100323 TXT 22.28 22.47 22.07 22.45 31085 20100324 TXT 22.28 22.58 22.15 22.28 24703 20100325 TXT 22.53 22.56 21.73 21.77 49748 20100326 TXT 21.9 22.3 21.62 21.68 38683 20100329 TXT 21.84 21.95 21.49 21.7 40553 20100330 TXT 21.76 22 21.41 21.56 32409 20100331 TXT 21.48 21.59 21.18 21.23 36943 20100401 TXT 21.42 21.57 21.17 21.4 36557 20100405 TXT 21.54 21.61 21.16 21.33 49152 20100406 TXT 21.23 21.82 21.12 21.57 37554 20100407 TXT 21.45 22.27 21.25 22.18 96531 20100408 TXT 22.11 22.25 21.91 22.17 38680 20100409 TXT 22.23 22.3 21.67 22.09 31193 20100412 TXT 22.1 22.66 22.06 22.59 38606 20100413 TXT 22.49 22.66 22.37 22.55 32789 20100414 TXT 22.64 22.78 22.24 22.76 43751 20100415 TXT 22.48 22.71 22.27 22.33 48089 20100416 TXT 22.42 22.43 21.61 21.94 56083 20100419 TXT 21.75 21.89 21.09 21.56 40196 20100420 TXT 21.67 22 21.5 21.87 30741 20100421 TXT 21.66 22.17 21.58 21.6 56747 20100422 TXT 22.18 24.36 21.99 24.23 164175 20100423 TXT 24.31 24.33 23.48 23.85 69210 20100426 TXT 23.94 25.3 23.92 24.55 77962 20100427 TXT 24.45 24.45 23.12 23.25 74654 20100428 TXT 23.41 23.96 23.22 23.61 45612 20100429 TXT 23.91 24.2 23.44 23.52 32942 20100430 TXT 23.5 23.72 22.84 22.84 36452 20100503 TXT 23 23.55 22.94 23.49 44525 20100504 TXT 23.01 23.45 22.7 22.93 59970 20100505 TXT 22.59 23.36 22.11 23.27 68902 20100506 TXT 23.14 23.79 20 22.5 77772 20100507 TXT 22.49 22.49 20.22 20.38 157695 20100510 TXT 22.01 22.56 21.75 22.39 63241 20100511 TXT 21.63 23 21.63 22.64 56401 20100512 TXT 22.89 24.2 22.89 24.09 57260 20100513 TXT 24.04 24.08 23.39 23.53 28504 20100514 TXT 23.25 23.44 22.31 22.57 48405 20100517 TXT 22.55 22.9 21.38 21.95 73374 20100518 TXT 23.06 23.06 21.41 21.5 64976 20100519 TXT 21.29 21.59 20.63 21.07 48904 20100520 TXT 20.21 20.44 19.32 19.41 85643 20100521 TXT 19.04 20.76 18.89 20.57 106973 20100524 TXT 20.43 21.01 20.19 20.22 44856 20100525 TXT 19.21 19.76 18.89 19.52 113330 20100526 TXT 19.74 21.05 19.72 20.27 111000 20100527 TXT 21.03 21.28 20.64 21.26 42259 20100528 TXT 21.26 21.34 20.45 20.67 29001 20100601 TXT 20.11 20.68 19.87 19.89 44487 20100602 TXT 20.08 20.48 19.87 20.47 35835 20100603 TXT 20.57 20.85 20.22 20.65 35770 20100604 TXT 20.28 20.46 18.81 18.96 81034 20100607 TXT 19 19.04 18.15 18.21 60477 20100608 TXT 18.17 18.96 17.98 18.96 74831 20100609 TXT 19.07 19.34 18.53 18.68 59965 20100610 TXT 19.18 19.44 18.96 19.3 48065 20100611 TXT 18.96 19.51 18.96 19.46 33417 20100614 TXT 19.56 19.94 19.24 19.3 29404 20100615 TXT 19.61 20.28 19.55 20.24 36524 20100616 TXT 20.04 20.38 19.9 20.02 41014 20100617 TXT 20.15 20.16 19.56 19.95 28188 20100618 TXT 20 20.17 19.834 20.03 27147 20100621 TXT 20.5 20.65 19.9 20.01 31035 20100622 TXT 20.16 20.24 19.24 19.35 30431 20100623 TXT 19.35 19.38 18.82 19.02 47518 20100624 TXT 18.92 19.14 18.52 18.59 47043 20100625 TXT 18.72 19.31 18.57 19.31 73939 20100628 TXT 19.32 19.41 18.62 18.66 51878 20100629 TXT 18.25 18.28 16.71 16.8 143435 20100630 TXT 16.58 17.335 16.58 16.97 72412 20100701 TXT 16.87 17 16.1 16.37 109536 20100702 TXT 16.45 16.5 15.88 16.07 60701 20100706 TXT 16.41 16.74 16.02 16.28 60671 20100707 TXT 16.31 17.18 16.23 17.17 68334 20100708 TXT 17.12 17.3 16.66 17.04 50855 20100709 TXT 17.07 17.89 17.05 17.8 54789 20100712 TXT 17.8 18.03 17.48 17.68 39380 20100713 TXT 18.41 18.9 18.2 18.39 - ---- - -25421 20100127 SAI 18.28 18.34 18.19 18.27 32181 20100128 SAI 18.28 18.43 18.16 18.29 27537 20100129 SAI 18.33 18.5 18.23 18.33 34509 20100201 SAI 18.28 18.62 18.11 18.6 35129 20100202 SAI 18.59 18.64 18.39 18.64 42698 20100203 SAI 18.57 18.69 18.5 18.53 35039 20100204 SAI 18.38 18.62 18.38 18.48 53648 20100205 SAI 18.47 18.68 18.37 18.68 61950 20100208 SAI 18.65 18.67 18.34 18.35 26006 20100209 SAI 18.57 18.57 18.26 18.51 25320 20100210 SAI 18.44 18.57 18.38 18.56 31906 20100211 SAI 18.59 18.67 18.36 18.66 23536 20100212 SAI 18.56 18.77 18.44 18.75 26292 20100216 SAI 18.8 19.1 18.72 19 32021 20100217 SAI 19.05 19.18 18.97 19.17 26044 20100218 SAI 19.15 19.24 19.04 19.06 24999 20100219 SAI 18.99 19.14 18.82 19.11 34400 20100222 SAI 19.11 19.2 18.96 19.01 14752 20100223 SAI 18.95 19.08 18.92 19.07 30027 20100224 SAI 19.14 19.48 19.07 19.48 41439 20100225 SAI 19.25 19.43 19.06 19.39 30501 20100226 SAI 19.45 19.75 19.44 19.7 162914 20100301 SAI 19.7 19.76 19.47 19.51 26636 20100302 SAI 19.67 19.7 19.28 19.41 41877 20100303 SAI 19.49 19.49 19.2 19.22 34553 20100304 SAI 19.36 19.45 19.15 19.2 33913 20100305 SAI 19.3 19.42 19.19 19.31 34397 20100308 SAI 19.33 19.37 19.24 19.33 31140 20100309 SAI 19.28 19.51 19.27 19.49 30677 20100310 SAI 19.48 19.5 19.34 19.47 24065 20100311 SAI 19.4 19.43 19.26 19.39 25510 20100312 SAI 19.4 19.43 19.25 19.3 15151 20100315 SAI 19.3 19.35 19.21 19.35 16853 20100316 SAI 19.3 19.33 19.22 19.32 16970 20100317 SAI 19.3 19.39 19.23 19.27 21840 20100318 SAI 19.21 19.34 19.06 19.14 28238 20100319 SAI 19.16 19.18 18.78 19.14 52677 20100322 SAI 19.07 19.48 18.98 19.43 29113 20100323 SAI 19.4 19.48 19.14 19.24 27853 20100324 SAI 19.22 19.28 19.04 19.05 18731 20100325 SAI 19.12 19.22 19.08 19.1 15765 20100326 SAI 19.17 19.31 19.07 19.26 24784 20100329 SAI 19.35 19.35 18.9 18.91 33623 20100330 SAI 18.97 19.06 18.82 18.98 36347 20100331 SAI 17.86 18.1 17.5 17.7 157248 20100401 SAI 17.7 17.8 17.32 17.42 80600 20100405 SAI 17.49 17.55 17.36 17.42 44256 20100406 SAI 17.41 17.47 17.16 17.3 39445 20100407 SAI 17.34 17.34 16.99 17.2 59865 20100408 SAI 17.15 17.23 17.05 17.2 34529 20100409 SAI 17.29 17.57 17.22 17.51 46585 20100412 SAI 17.66 17.66 17.34 17.4 48532 20100413 SAI 17.41 17.58 17.31 17.5 37805 20100414 SAI 17.51 17.74 17.48 17.72 45872 20100415 SAI 17.92 18.14 17.72 18 69106 20100416 SAI 17.94 18.005 17.66 17.97 68437 20100419 SAI 18.01 18.21 17.91 18.19 53966 20100420 SAI 17.97 18.3 17.83 18.29 60218 20100421 SAI 18.21 18.35 18.14 18.26 47815 20100422 SAI 18.2 18.39 18.04 18.36 46414 20100423 SAI 18.36 18.46 18.18 18.46 39503 20100426 SAI 18.36 18.42 18.1899 18.22 50373 20100427 SAI 18.15 18.21 17.99 18.01 51396 20100428 SAI 18.11 18.11 17.58 17.73 44267 20100429 SAI 17.74 17.84 17.67 17.73 25016 20100430 SAI 17.77 17.8 17.34 17.41 63264 20100503 SAI 17.49 17.57 17.37 17.44 32041 20100504 SAI 17.31 17.5 17.21 17.46 34072 20100505 SAI 17.42 17.85 17.34 17.43 23353 20100506 SAI 17.36 17.69 17.07 17.29 52925 20100507 SAI 17.28 17.62 17.22 17.54 80882 20100510 SAI 17.87 17.87 17.31 17.43 47543 20100511 SAI 17.31 17.4 16.98 17.15 78147 20100512 SAI 17.22 17.26 17.13 17.25 41221 20100513 SAI 17.24 17.34 17.17 17.21 24229 20100514 SAI 17.21 17.42 17.06 17.22 39474 20100517 SAI 17.2 17.63 17.2 17.58 45600 20100518 SAI 17.59 17.695 17.49 17.53 51116 20100519 SAI 17.43 17.59 17.3 17.34 42237 20100520 SAI 17.14 17.27 16.9 16.9 43867 20100521 SAI 16.74 17.17 16.65 17.16 51934 20100524 SAI 17.02 17.24 17 17.13 24121 20100525 SAI 16.93 17.14 16.71 17.12 38161 20100526 SAI 17.2 17.33 16.97 17.03 37954 20100527 SAI 17.23 17.29 17.01 17.25 20276 20100528 SAI 17.24 17.31 17.1 17.19 21695 20100601 SAI 17.12 17.26 16.95 17.07 21969 20100602 SAI 17.11 17.44 17.0399 17.44 22056 20100603 SAI 17.31 17.79 17.31 17.62 31358 20100604 SAI 17.55 17.95 17.37 17.58 57694 20100607 SAI 17.65 17.75 17.4 17.49 35298 20100608 SAI 17.53 17.53 17.28 17.39 44461 20100609 SAI 17.41 17.59 17.34 17.4 35663 20100610 SAI 17.5 17.85 17.5 17.69 45181 - ---- - -109956 20100803 MI 7.44 7.48 7.29 7.33 66131 20100804 MI 7.34 7.37 7.01 7.17 78494 20100805 MI 7.12 7.27 7.05 7.24 51431 20100806 MI 7.11 7.15 6.96 7.14 42269 20100809 MI 7.27 7.27 6.92 7.07 76150 20100810 MI 6.95 7.07 6.9 6.98 57744 20100811 MI 6.81 6.85 6.56 6.61 78995 20100812 MI 6.56 6.73 6.45 6.67 112671 20100813 MI 6.68 6.87 6.62 6.7 59285 20100816 MI 6.64 6.64 6.37 6.56 82597 20100817 MI 6.69 6.72 6.47 6.5 87262 20100819 MI 6.43 6.52 6.17 6.27 90869 20100820 MI 6.21 6.41 6.17 6.36 83007 20090821 MIL 67.88 68.17 67.54 67.93 5333 20090824 MIL 67.7 67.79 66.87 67.17 3409 20090825 MIL 67.31 67.38 66.65 66.81 3552 20090826 MIL 66.71 67.112 66.57 66.77 4027 20090827 MIL 66.72 67.0599 65.92 66.97 3215 20090828 MIL 67.27 67.75 66.42 66.79 3598 20090831 MIL 66.48 66.98 65.78 66.23 3461 20090901 MIL 66.18 66.97 64.91 65.37 5180 20090902 MIL 65.05 65.55 64.71 65.38 4638 20090903 MIL 65.39 65.7 64.78 65.24 6166 20090904 MIL 65.16 66.25 64.92 66.25 6221 20090909 MIL 67.75 69.28 67.05 69.17 7596 20090910 MIL 69.28 69.29 68.48 68.71 4816 20090911 MIL 68.8 69.73 68.41 69.44 3383 20090914 MIL 69.08 70.4596 69.08 70.26 4250 20090915 MIL 70.25 70.25 68.65 69.46 5164 20090916 MIL 69.71 71.41 69.45 71.41 6061 20090917 MIL 71.12 71.85 70.66 71.62 5360 20090918 MIL 70.3 72.65 70.3 72.43 7074 20090921 MIL 71.97 72.33 71.27 71.37 4664 20090922 MIL 71.59 71.64 70.6 71.1 2891 20090923 MIL 71.13 71.19 70.12 70.15 3412 20090924 MIL 70.25 70.29 69.48 69.63 3366 20090925 MIL 69.27 69.98 69.17 69.77 2703 20090928 MIL 69.91 70.41 69.47 69.82 2637 20090929 MIL 70.19 71.1 69.76 70.95 3540 20090930 MIL 70.66 71.03 69.26 70.33 4079 20091001 MIL 69.91 70.53 69.52 69.52 4006 20091002 MIL 69.22 69.51 68.42 68.68 4527 20091005 MIL 68.95 70.08 68.37 70.08 3784 20091006 MIL 70 71.1 69.4555 70.83 3447 20091007 MIL 70.55 70.73 70.01 70.53 2548 20091008 MIL 70.8 71.09 70.42 70.58 3782 20091009 MIL 70.6 71.13 70.32 70.77 4307 20091012 MIL 70.79 71.67 70.66 71.56 3343 20091013 MIL 71.44 71.79 70.48 70.86 4407 20091014 MIL 71.38 72.19 70.99 72.19 7756 20091015 MIL 72.19 72.59 71.65 72.25 5641 20091016 MIL 72.14 72.14 71.31 71.62 2628 20091019 MIL 71.76 72.69 71.35 72.66 2938 20091020 MIL 72.61 72.61 71.5 71.69 4088 20091021 MIL 71.75 72.39 71.42 71.81 3271 20091022 MIL 71.78 71.78 70.81 71 6757 20091023 MIL 70.95 71.08 70.31 70.75 4125 20091026 MIL 70.5 70.84 69.24 69.42 4514 20091027 MIL 69.35 70.31 69.25 69.84 5740 20091028 MIL 70.02 70.02 68.06 68.11 5032 20091105 MIL 68.41 69.55 68.34 68.75 4657 20091106 MIL 67.3 68.95 66.98 67.66 12010 20091109 MIL 68.06 68.72 67.532 68.7 4445 20091110 MIL 68.73 69.23 68.62 69.06 4305 20091111 MIL 69 69.7375 68.57 68.69 3078 20091112 MIL 68.44 68.94 67.76 68.1 2764 20091113 MIL 68.07 68.63 67.65 68.41 2234 20091116 MIL 68.44 68.68 68.14 68.54 4822 20091117 MIL 68.53 68.74 68.13 68.6 4251 20091118 MIL 68.51 68.58 67.4 67.76 4149 20091119 MIL 67.66 68.17 67.13 67.95 3524 20091120 MIL 67.67 67.95 67.52 67.73 6560 20091123 MIL 67.97 68.85 67.97 68.3 3116 20091124 MIL 68.14 68.73 67.87 68.56 3020 20091125 MIL 68.44 68.59 67.94 68.27 5982 20091127 MIL 67.21 68.16 66.65 67.85 2250 20091130 MIL 67.99 68.15 67.5 68.1 3187 20091201 MIL 68.43 69.13 68.05 68.94 3482 20091202 MIL 68.78 69.98 68.78 69.77 4478 20091203 MIL 69.71 70.45 69.47 69.54 4471 20091204 MIL 70.04 70.67 69.78 70.43 5166 20091207 MIL 69.98 70.61 69.88 69.97 2991 20091208 MIL 69.79 70.03 69.13 69.72 2934 20091209 MIL 69.68 69.71 68.7 69.51 2804 20091210 MIL 69.7 70.93 69.52 70.37 2613 20091211 MIL 70.57 70.68 69.73 70.23 2874 20091214 MIL 70.56 71.28 70.44 71.03 3827 20091215 MIL 70.96 71.69 70.79 71.51 6502 20091216 MIL 71.48 72.41 71.27 71.76 4475 20091217 MIL 71.61 71.67 71.06 71.21 2284 20091218 MIL 71.15 71.65 70.08 71.12 4105 20091221 MIL 71.4 72.03 71.1701 71.57 1263 20091222 MIL 71.56 72.34 71.56 72.14 1962 20091223 MIL 72.13 72.66 71.87 72.56 1881 20091224 MIL 72.5 72.63 72.16 72.5 478 20091228 MIL 72.5 72.72 72.34 72.69 934 20091229 MIL 72.72 73.02 72.39 72.68 - ---- - -115183 20100408 DHI 11.9 12.03 11.75 12.01 79148 20100409 DHI 12.04 12.185 11.98 12.14 38701 20100412 DHI 12.19 12.24 11.89 12.03 67469 20100413 DHI 12.04 12.27 12.01 12.18 69399 20100414 DHI 12.25 12.81 12.24 12.65 101835 20100415 DHI 12.63 12.74 12.51 12.6 56106 20100416 DHI 12.5 12.58 12.025 12.37 93481 20100419 DHI 12.32 12.4 12.04 12.34 48289 20100420 DHI 12.41 12.79 12.255 12.76 59225 20100421 DHI 12.77 13.1 12.65 12.98 63332 20100422 DHI 12.92 13.855 12.77 13.69 112278 20100423 DHI 13.79 14.54 13.72 14.17 123148 20100426 DHI 14.23 14.48 13.81 13.88 63999 20100427 DHI 13.75 14.03 13.37 13.41 91512 20100428 DHI 13.48 50.8 13.47 13.62 74409 20100429 DHI 13.75 14.42 13.63 14.24 111553 20100430 DHI 15.07 15.44 14.63 14.69 154285 20100503 DHI 14.71 15.2 14.64 14.97 70491 20100504 DHI 14.75 14.82 14.22 14.63 86924 20100505 DHI 14.4 14.62 14.03 14.14 77508 20100506 DHI 14 14.38 12.64 13.65 108580 20100507 DHI 13.68 13.87 12.92 13.06 99551 20100510 DHI 13.67 14.01 13.37 13.94 81169 20100511 DHI 13.68 14.38 13.54 13.84 89447 20100512 DHI 13.93 14.18 13.82 14.04 50532 20100513 DHI 14.02 14.02 13.33 13.46 72709 20100514 DHI 13.29 13.34 12.81 13.11 69260 20100517 DHI 13.08 13.32 12.62 13.3 75588 20100518 DHI 13.42 13.75 12.96 13.02 76647 20100519 DHI 12.81 13.3 12.38 12.67 141218 20100520 DHI 12.29 12.56 12.13 12.14 110594 20100521 DHI 12.02 12.4684 11.86 12.26 109993 20100524 DHI 12.19 12.57 12.05 12.06 64159 20100525 DHI 11.67 12.14 11.57 12.1 104797 20100526 DHI 12.43 12.67 11.97 12.01 95058 20100527 DHI 12.25 12.35 11.92 12.34 58922 20100528 DHI 12.32 12.48 12.12 12.19 48966 20100601 DHI 12.1 12.29 11.76 11.77 75995 20100602 DHI 11.78 12.16 11.75 12.13 64535 20100603 DHI 12.13 12.21 11.69 11.78 78210 20100604 DHI 11.6 11.68 11.25 11.34 72681 20100607 DHI 11.39 11.46 10.82 10.89 64236 20100608 DHI 10.92 11.05 10.44 10.84 131892 20100609 DHI 11.08 11.1 10.46 10.54 110135 20100610 DHI 10.79 11.41 10.6392 11.3 138522 20100611 DHI 11.15 11.28 10.97 11.26 63014 20100614 DHI 11.35 11.41 10.99 11.07 67270 20100615 DHI 11.16 11.39 11.07 11.39 72290 20100616 DHI 11.22 11.49 11.07 11.24 77644 20100617 DHI 11.19 11.22 10.63 10.94 82669 20100618 DHI 10.92 10.96 10.66 10.75 59399 20100621 DHI 10.9 10.99 10.48 10.54 75845 20100622 DHI 10.52 10.67 10.16 10.22 81665 20100623 DHI 10.22 10.6 10.03 10.47 85873 20100624 DHI 10.48 10.76 10.29 10.58 101041 20100625 DHI 10.57 10.57 10.26 10.47 71931 20100628 DHI 10.5 10.59 10.29 10.36 86558 20100629 DHI 10.3 10.39 9.85 9.96 95902 20100630 DHI 9.96 10.15 9.82 9.83 92595 20100701 DHI 9.78 10 9.58 9.85 118264 20100702 DHI 9.89 9.89 9.41 9.71 95166 20100706 DHI 9.88 10.05 9.7 9.79 110932 20100707 DHI 9.8 10.23 9.775 10.2 83742 20100708 DHI 10.29 10.42 9.74 9.8 166530 20100709 DHI 9.81 10.35 9.78 10.25 61343 20100712 DHI 10.23 10.27 9.98 10.1 38194 20100713 DHI 10.17 10.5 10.1075 10.43 65541 20100714 DHI 10.33 10.36 10.06 10.34 66239 20100715 DHI 10.35 10.69 10.2 10.62 103381 20100716 DHI 10.55 10.57 10.03 10.1 74508 20100719 DHI 10.17 10.21 9.85 9.97 65190 20100720 DHI 9.8 10.48 9.72 10.39 61981 20100721 DHI 10.51 10.54 10.15 10.2 60966 20100722 DHI 10.33 10.74 10.31 10.55 53182 20100723 DHI 10.5 10.9 10.41 10.85 54987 20100726 DHI 10.82 11.2701 10.76 11.17 79047 20100727 DHI 11.24 11.38 11.01 11.08 84495 20100728 DHI 11.07 11.14 10.55 10.64 51520 20100729 DHI 10.76 11.01 10.5775 10.88 83513 20100730 DHI 10.74 11.09 10.61 11.02 73305 20100802 DHI 11.22 11.38 10.94 11.25 70449 20100803 DHI 11.09 11.3 10.48 10.6 122024 20100804 DHI 10.65 10.82 10.46 10.48 46427 20100805 DHI 10.31 10.53 10.28 10.42 45848 20100806 DHI 10.33 10.66 10.24 10.6 55464 20100809 DHI 10.9 11.14 10.76 11.06 61510 20100810 DHI 10.9 10.98 10.72 10.83 48069 20100811 DHI 10.61 10.67 10.46 10.54 57940 20100812 DHI 10.27 10.47 10.185 10.21 44969 20100813 DHI 10.18 10.38 10.13 10.24 45157 20100816 DHI 10.15 10.34 10.085 10.18 31624 20100817 DHI 10.31 10.58 10.19 10.47 41535 20100819 DHI 10.56 10.58 10.34 10.43 43980 20100820 DHI 10.32 10.39 - ---- - -10.52 53636 20091109 GCI 10.71 11.17 10.69 11.16 58843 20091110 GCI 11.26 11.41 10.85 11.12 55264 20091111 GCI 11.38 11.49 10.99 11.23 46486 20091112 GCI 11.18 11.39 10.69 10.75 71831 20091113 GCI 10.88 11.08 10.734 10.8 64764 20091116 GCI 10.86 11.53 10.81 11.5 51858 20091117 GCI 11.49 11.58 11.17 11.41 47613 20091118 GCI 11.41 11.5 11.21 11.47 46623 20091119 GCI 11.34 11.34 10.8 10.89 37494 20091120 GCI 10.74 10.83 10.33 10.38 43022 20091123 GCI 10.7 11.02 10.44 10.47 56596 20091124 GCI 10.55 10.645 10.34 10.45 37222 20091125 GCI 10.44 10.79 10.42 10.62 27077 20091127 GCI 10.07 10.445 9.8 10.32 19210 20091130 GCI 10.26 10.38 9.72 9.89 109242 20091201 GCI 10.05 10.18 9.68 10.01 66807 20091202 GCI 10.04 10.09 9.63 9.87 69627 20091203 GCI 9.94 10.2 9.83 9.85 53167 20091204 GCI 10.19 10.35 9.75 10.29 69043 20091207 GCI 10.26 11.09 10.26 11.09 86784 20091208 GCI 11.05 12 11.02 11.8 180270 20091209 GCI 11.79 12.22 11.45 12 97350 20091210 GCI 12.02 13.34 12.02 12.84 148605 20091211 GCI 12.81 13.29 12.71 13.16 79161 20091214 GCI 13.4 14.15 13.4 13.83 93756 20091215 GCI 13.81 14.07 13.76 13.9 64457 20091216 GCI 13.95 14.14 13.73 13.9 87184 20091217 GCI 13.8 14.38 13.6 14.15 76069 20091218 GCI 14.33 14.42 13.8216 13.98 55544 20091221 GCI 14.14 14.25 13.9375 14.03 86451 20091222 GCI 13.93 14.41 13.85 14.41 56625 20091223 GCI 14.76 15.49 14.75 15.42 108637 20091224 GCI 15.43 15.75 15.43 15.63 23133 20091228 GCI 15.7 15.99 15.11 15.23 37212 20091229 GCI 15.3 15.54 15 15.06 32033 20091230 GCI 14.96 15.02 14.8 15.02 38629 20091231 GCI 15 15.15 14.81 14.85 21593 20100104 GCI 14.97 15.67 14.76 15.35 84904 20100105 GCI 15.4 16.39 15.16 16.24 91946 20100106 GCI 16.17 16.695 16.11 16.43 57131 20100107 GCI 16.3 16.9 16.3 16.88 60486 20100108 GCI 16.73 16.94 16.6 16.76 53499 20100111 GCI 16.78 17.33 16.665 17.25 63076 20100112 GCI 17 17.17 16.22 16.4 84332 20100113 GCI 16.42 16.72 15.74 16.45 43085 20100114 GCI 16.36 16.59 16.17 16.22 42540 20100115 GCI 16.22 16.4 15.37 16.1 73461 20100119 GCI 16.09 16.72 16.04 16.31 52365 20100120 GCI 16.11 16.24 15.75 15.96 55061 20100121 GCI 15.97 16.34 15.585 15.71 57141 20100122 GCI 15.64 16.14 15.32 15.42 58761 20100125 GCI 15.55 16.13 15.55 16.04 54054 20100126 GCI 15.97 16.27 15.74 15.84 55859 20100127 GCI 16.2 16.99 15.5746 16.14 58013 20100128 GCI 16.24 16.36 15.6 16.24 68334 20100129 GCI 16.36 16.78 15.91 16.15 101551 20100201 GCI 15.29 15.43 14.12 15.02 226283 20100202 GCI 15 15.33 14.87 15.08 83530 20100203 GCI 15.03 15.38 14.56 14.61 66050 20100204 GCI 14.13 14.23 13.4 13.66 108926 20100205 GCI 13.77 13.8 12.77 13.53 84973 20100208 GCI 13.53 13.87 13.14 13.68 72360 20100209 GCI 13.72 14.42 13.72 13.97 76831 20100210 GCI 14 14.3 13.6 13.91 49941 20100211 GCI 13.92 14.29 13.74 14.21 40428 20100212 GCI 13.98 14.38 13.75 14.29 54595 20100216 GCI 14.31 14.88 14.27 14.8 44696 20100217 GCI 14.81 15.07 14.79 14.95 42212 20100218 GCI 14.92 15.41 14.82 15.27 44087 20100219 GCI 15.19 15.5 15.11 15.34 41790 20100222 GCI 15.36 15.43 14.8 14.96 37286 20100223 GCI 14.91 15.11 14.69 14.8 35911 20100224 GCI 14.9 15.01 14.75 15 31657 20100225 GCI 14.75 15.35 14.55 15.32 48959 20100226 GCI 15.32 15.5 15.01 15.15 62473 20100301 GCI 15.22 16.04 15.22 15.93 43014 20100302 GCI 15.94 16.18 15.85 15.95 33268 20100303 GCI 16.06 16.34 15.95 16.07 37700 20100304 GCI 16.14 16.25 15.725 16.07 32574 20100305 GCI 16.22 16.39 16.075 16.27 50969 20100308 GCI 16.3 16.38 16.15 16.16 26830 20100309 GCI 16.12 16.21 15.92 16.06 30298 20100310 GCI 16.01 16.365 15.97 16.08 25871 20100311 GCI 15.97 16.32 15.88 16.29 20281 20100312 GCI 16.39 16.43 15.78 15.9 34954 20100315 GCI 15.57 16.12 15.57 16.06 35023 20100316 GCI 16.02 16.63 16.02 16.42 48410 20100317 GCI 16.48 16.84 16.4 16.78 41899 20100318 GCI 16.69 16.84 16.215 16.4 61385 20100319 GCI 16.51 16.64 16.05 16.06 81022 20100322 GCI 16.01 16.49 15.74 16.42 38887 20100323 GCI 16.49 16.8 16.19 16.72 30814 20100324 GCI 16.59 16.64 16.29 16.55 32863 20100325 GCI 16.62 16.96 16.47 16.5 33481 - ---- - -27.83 27.59 27.73 4771 20100114 FII 27.71 27.71 27.3002 27.5 5040 20100115 FII 27.43 27.55 27.22 27.3 7268 20100119 FII 27.4 27.76 27.25 27.75 6077 20100120 FII 27.44 27.62 27.21 27.48 6555 20100121 FII 27.56 27.66 26.88 26.88 10241 20100122 FII 26.91 26.91 25.73 25.74 14459 20100125 FII 25.97 26.49 25.83 25.98 11494 20100126 FII 25.89 26.09 25.56 25.59 11167 20100127 FII 25.59 26.67 25.52 26.5 17662 20100128 FII 26.6 26.78 25.78 26.02 14988 20100129 FII 25.62 26.06 24.87 25.38 49417 20100201 FII 25.44 26.17 25.15 26.13 24741 20100202 FII 26.05 26.73 26 26.7 24312 20100203 FII 25.28 25.29 24.59 24.63 26715 20100204 FII 24.51 24.82 23.92 24.3 29017 20100205 FII 24.35 24.75 24.05 24.65 17862 20100208 FII 24.71 24.71 23.9401 23.98 14975 20100209 FII 24.14 24.32 23.85 24.16 15197 20100210 FII 24.07 25 24.03 24.62 13832 20100211 FII 24.58 24.66 24.2 24.57 9726 20100212 FII 24.44 24.56 24.29 24.53 9574 20100216 FII 24.66 25.44 24.57 25.41 17468 20100217 FII 25.67 25.67 25.2 25.32 10075 20100218 FII 25.36 25.71 25.26 25.55 13536 20100219 FII 25.45 26.01 25.4 25.81 18718 20100222 FII 25.96 25.96 25.59 25.74 10300 20100223 FII 25.74 25.81 25.16 25.21 15194 20100224 FII 25.34 25.485 25.22 25.4 8967 20100225 FII 25.15 25.24 24.87 25.19 11435 20100226 FII 25.33 25.33 24.79 25.01 14397 20100301 FII 25.02 25.19 24.94 25.1 14522 20100302 FII 25.24 25.4 25.07 25.34 9326 20100303 FII 25.4 25.79 25.37 25.48 12870 20100304 FII 25.41 25.79 25.36 25.74 9764 20100305 FII 25.87 26.13 25.75 25.98 9363 20100308 FII 26.02 26.1 25.83 25.88 9738 20100309 FII 25.7 26.16 25.6 25.98 14676 20100310 FII 25.97 26.105 25.89 26.03 11836 20100311 FII 25.88 26.29 25.745 26.26 11157 20100312 FII 26.35 26.42 25.94 26.19 7736 20100315 FII 26.15 26.17 25.78 25.94 6718 20100316 FII 26.06 26.14 25.76 25.85 8677 20100317 FII 25.97 26.47 25.96 26.32 14320 20100318 FII 26.4 26.52 26.25 26.38 10376 20100319 FII 26.43 26.58 25.77 25.81 12240 20100322 FII 25.69 26.06 25.61 26.05 5717 20100323 FII 26.06 26.23 25.97 26.22 6382 20100324 FII 26.05 26.25 25.911 26.17 9000 20100325 FII 26.4 26.5 26.16 26.25 15618 20100326 FII 26.31 26.37 26.105 26.32 8730 20100329 FII 26.38 26.44 26.11 26.23 5731 20100330 FII 26.21 26.37 26.11 26.29 5215 20100331 FII 26.23 26.83 26.12 26.38 13526 20100401 FII 26.58 26.78 26.26 26.47 9573 20100405 FII 26.54 26.69 26.26 26.66 9840 20100406 FII 26.52 26.94 26.25 26.78 10235 20100407 FII 26.78 26.78 26.37 26.52 13322 20100408 FII 26.45 26.49 26.25 26.46 8706 20100409 FII 26.47 26.57 26.31 26.48 7884 20100412 FII 26.49 26.54 26.27 26.36 9899 20100413 FII 26.31 26.83 26.31 26.82 11081 20100414 FII 27.1 27.32 26.82 26.95 10044 20100415 FII 26.96 27.3 26.85 27.26 8610 20100416 FII 27.21 27.22 26.34 26.76 14921 20100419 FII 26.57 26.92 26.44 26.76 8829 20100420 FII 26.93 26.94 26.245 26.66 10129 20100421 FII 26.59 26.76 26.46 26.62 11702 20100422 FII 26.32 26.5 26.13 26.39 23898 20100423 FII 26.25 26.25 25.46 25.9 29989 20100426 FII 25.79 25.91 25.22 25.22 20988 20100427 FII 25.02 25.0299 24.18 24.18 30407 20100428 FII 24.4 24.6 23.95 24.25 29624 20100429 FII 24.49 24.77 24.39 24.66 22235 20100430 FII 24.63 24.83 24.11 24.12 22598 20100503 FII 24.4 24.56 24.22 24.44 20771 20100504 FII 24.12 24.18 23.81 24 23218 20100505 FII 23.49 24.17 23.33 23.87 21623 20100506 FII 23.67 23.98 22.56 23.55 39433 20100507 FII 23.48 24.18 23.28 23.53 40715 20100510 FII 24.44 24.74 23.45 23.81 33052 20100511 FII 23.6 23.74 23.35 23.5 20202 20100512 FII 23.56 23.86 23.53 23.82 14186 20100513 FII 23.72 23.86 23.435 23.44 11646 20100514 FII 23.31 23.575 23 23.16 21848 20100517 FII 23.19 23.5 22.91 23.29 13004 20100518 FII 23.52 23.53 22.71 22.81 18478 20100519 FII 22.68 23.21 22.4 23.11 21893 20100520 FII 22.77 23.01 22.28 22.28 21301 20100521 FII 21.99 22.81 21.83 22.65 21337 20100524 FII 22.81 23.04 22.4 22.4 17874 20100525 FII 21.91 22.55 21.8 22.51 20575 20100526 FII 22.68 22.83 22.27 22.38 16335 20100527 FII 22.72 22.77 22.27 22.73 19763 20100528 FII 22.61 22.69 22.1 22.21 - ---- - -23.08 64605 20100225 SBUX 22.64 22.98 22.43 22.9 93118 20100226 SBUX 22.87 22.99 22.68 22.91 60499 20100301 SBUX 22.94 23.34 22.91 23.29 63517 20100302 SBUX 23.28 23.4 23.08 23.33 85610 20100303 SBUX 23.29 23.38 22.94 23.06 55174 20100304 SBUX 23.09 23.17 22.87 22.92 64462 20100305 SBUX 23.01 23.39 22.87 23.37 61643 20100308 SBUX 23.26 23.59 23.25 23.32 44985 20100309 SBUX 23.2 23.75 23.2 23.62 66785 20100310 SBUX 23.56 24.27 23.51 24.23 122328 20100311 SBUX 24.09 24.67 24.04 24.27 89894 20100312 SBUX 24.43 24.48 24.14 24.28 64166 20100315 SBUX 24.34 24.5 24.24 24.42 59208 20100316 SBUX 24.87 25.37 24.86 25.29 169040 20100317 SBUX 25.26 25.66 25.13 25.56 106829 20100318 SBUX 25.45 25.5 24.97 25.02 107083 20100319 SBUX 24.97 25.15 24.75 24.97 110192 20100322 SBUX 24.74 25.38 24.35 25.24 81647 20100323 SBUX 25.26 25.43 24.95 25.41 88279 20100324 SBUX 25.89 26 25.24 25.29 121490 20100325 SBUX 25.06 25.13 24.15 24.21 189824 20100326 SBUX 24.4 24.83 24.39 24.59 102317 20100329 SBUX 24.7 24.77 24.2899 24.61 68593 20100330 SBUX 24.43 24.63 24.24 24.56 63930 20100331 SBUX 24.5 24.54 24.2 24.27 75442 20100401 SBUX 24.4 24.73 23.95 24.24 77755 20100405 SBUX 24.16 24.78 24.11 24.61 78828 20100406 SBUX 24.44 24.7 24.35 24.6 57945 20100407 SBUX 24.77 25.025 24.69 24.91 84059 20100408 SBUX 24.76 25 24.63 24.83 71673 20100409 SBUX 24.93 24.95 24.45 24.72 61909 20100412 SBUX 24.7 24.79 24.32 24.49 63051 20100413 SBUX 24.44 24.8 24.32 24.73 73523 20100414 SBUX 24.71 24.85 24.4 24.84 78828 20100415 SBUX 24.76 25.25 24.62 25.13 96031 20100416 SBUX 25.16 25.22 24.71 24.96 109072 20100419 SBUX 25.03 25.235 24.56 24.9 84914 20100420 SBUX 25.06 25.29 24.62 25.26 75338 20100421 SBUX 25.2 25.42 25 25.39 137329 20100422 SBUX 26 27.45 25.67 27.25 310504 20100423 SBUX 27.01 27.29 26.75 27.26 104491 20100426 SBUX 27.07 27.59 27 27.39 79381 20100427 SBUX 27.43 27.5 26.45 26.53 96204 20100428 SBUX 26.65 26.88 26.12 26.22 105977 20100429 SBUX 26.33 26.73 26.26 26.6 75962 20100430 SBUX 26.67 26.74 25.98 25.98 75038 20100503 SBUX 26.03 27.25 25.98 27.18 96655 20100504 SBUX 26.63 26.65 25.81 26.03 112351 20100505 SBUX 26.09 26.57 25.76 26.22 111534 20100506 SBUX 26 26.25 24.39 25.61 177871 20100507 SBUX 25.29 25.99 24.6501 25.4505 224074 20100510 SBUX 26.17 27.1 25.88 27.04 146675 20100511 SBUX 26.7 27.24 26.53 26.7 119968 20100512 SBUX 26.88 27.93 26.71 27.85 116675 20100513 SBUX 27.77 27.79 27.36 27.44 109628 20100514 SBUX 27.23 27.33 26.18 26.51 115408 20100517 SBUX 26.63 26.95 26.07 26.91 88257 20100518 SBUX 26.73 27.12 26.4 26.58 85599 20100519 SBUX 26.33 26.82 25.81 26.19 103567 20100520 SBUX 25.51 25.79 25.08 25.1 126002 20100521 SBUX 25.51 25.51 24.39 25.29 128619 20100524 SBUX 25.14 25.44 24.91 25.07 85397 20100525 SBUX 24.45 24.99 24.07 24.92 118768 20100526 SBUX 24.93 25.35 24.683 24.71 121023 20100527 SBUX 25.42 26.04 25.295 26.02 100519 20100528 SBUX 26.03 26.33 25.67 25.89 82621 20100601 SBUX 25.76 26.31 25.52 25.7 97673 20100602 SBUX 25.75 26.6 25.57 26.58 99660 20100603 SBUX 26.54 26.92 26.46 26.86 92290 20100604 SBUX 26.25 26.83 26 26.1525 114088 20100607 SBUX 26.21 26.25 25.51 25.54 98320 20100608 SBUX 25.55 25.91 25.2 25.85 99355 20100609 SBUX 26.06 26.72 26.01 26.31 118605 20100610 SBUX 26.56 27.01 26.4 26.98 94381 20100611 SBUX 26.77 27.21 26.74 27.15 86379 20100614 SBUX 27.43 27.86 27.28 27.46 87402 20100615 SBUX 27.59 27.94 27.414 27.93 86738 20100616 SBUX 27.77 28.17 27.62 27.99 94847 20100617 SBUX 28.01 28.11 27.6 27.98 71778 20100618 SBUX 27.99 28.36 27.74 28.09 94189 20100621 SBUX 28.29 28.5 27.86 28.02 66198 20100622 SBUX 28.03 28.48 27.15 27.23 103166 20100623 SBUX 27.23 27.52 26.9675 27.32 78959 20100624 SBUX 27.21 27.27 26.6 26.67 64796 20100625 SBUX 26.81 27.05 26.64 26.81 89347 20100628 SBUX 27.05 27.08 26.36 26.39 71981 20100629 SBUX 25.99 26.1 24.88 25.01 189466 20100630 SBUX 24.91 25.31 24.27 24.3 169650 20100701 SBUX 24.45 24.75 23.678 24.66 157496 20100702 SBUX 24.69 24.79 24.11 24.35 84655 20100707 SBUX 23.6 24.45 23.52 - ---- - -IRM 26.9 26.99 26.62 26.72 10259 20100408 IRM 26.56 26.61 26.27 26.52 9966 20100409 IRM 26.58 26.72 26.45 26.51 9527 20100412 IRM 26.53 26.64 26.42 26.5 13564 20100413 IRM 26.42 26.61 26.21 26.5 11057 20100414 IRM 26.55 26.915 26.33 26.88 20985 20100415 IRM 26.88 27.53 26.74 27.42 11802 20100416 IRM 27.42 27.67 27.05 27.22 14984 20100419 IRM 27.22 27.43 27.03 27.37 8724 20100420 IRM 27.46 27.82 27.32 27.74 10668 20100421 IRM 27.68 27.92 27.58 27.88 9912 20100422 IRM 27.66 28.35 27.52 28.31 11489 20100423 IRM 28.39 28.42 28.1 28.39 10657 20100426 IRM 28.31 28.49 28.15 28.26 9461 20100427 IRM 28.19 28.195 27.26 27.33 13317 20100428 IRM 27.65 28 27.51 28 10057 20100429 IRM 27.96 27.96 25.4 25.8 34844 20100430 IRM 25.86 25.89 24.97 25.15 20171 20100503 IRM 25.29 25.46 25.2 25.27 14151 20100504 IRM 24.95 25.12 24.61 25.07 19585 20100505 IRM 24.94 25.07 24.79 24.99 14365 20100506 IRM 24.77 25 22.62 23.89 18324 20100507 IRM 23.9 24.28 23.44 23.89 20275 20100510 IRM 24.9 25.31 24.76 25.11 17352 20100511 IRM 24.7 25.36 24.7 25.03 10954 20100512 IRM 25.08 25.5 25.08 25.5 8437 20100513 IRM 25.36 25.39 24.96 24.99 9970 20100514 IRM 24.89 24.94 24.29 24.48 9744 20100517 IRM 24.85 25.78 24.85 25.36 22097 20100518 IRM 26.02 26.25 25.44 25.67 23627 20100519 IRM 25.61 25.71 24.83 25.16 15450 20100520 IRM 24.74 24.74 23.89 23.95 17886 20100521 IRM 23.8 24.6 23.71 24.6 24111 20100524 IRM 24.45 24.66 24.18 24.23 15481 20100525 IRM 23.46 24.26 23.34 24.22 20356 20100526 IRM 24.49 24.89 24.171 24.25 14053 20100527 IRM 24.75 24.87 24.54 24.87 10104 20100528 IRM 24.87 24.87 24.365 24.52 8635 20100601 IRM 24.29 24.57 23.87 23.87 7601 20100602 IRM 24 24.33 23.85 24.33 9740 20100603 IRM 24.51 24.62 24.29 24.5 14658 20100604 IRM 24.15 24.2 23.29 23.39 19870 20100607 IRM 23.57 23.61 22.92 22.97 14789 20100608 IRM 23.1 23.27 22.74 23.2 23248 20100609 IRM 23.26 23.67 23.17 23.27 16938 20100610 IRM 23.63 23.84 23.299 23.82 13902 20100611 IRM 23.56 24.05 23.3955 24.05 9069 20100614 IRM 24.15 24.57 24.15 24.36 13273 20100615 IRM 24.57 25.01 24.56 25 9064 20100616 IRM 24.85 25.09 24.77 24.95 9551 20100617 IRM 24.95 24.95 24.26 24.47 13895 20100618 IRM 24.52 24.75 24.275 24.34 13772 20100621 IRM 24.72 24.74 23.96 24.02 12097 20100622 IRM 24.05 24.39 23.65 23.73 18518 20100623 IRM 23.56 23.6275 23.25 23.46 17087 20100624 IRM 23.48 23.91 23.345 23.5 19556 20100625 IRM 23.61 23.61 23.14 23.43 20754 20100628 IRM 23.6 23.61 23.21 23.27 9958 20100629 IRM 23.05 23.08 22.59 22.69 21197 20100630 IRM 22.61 22.93 22.44 22.46 17763 20100701 IRM 22.42 22.55 21.97 22.24 17542 20100702 IRM 22.21 22.41 21.96 22.01 7226 20100706 IRM 22.4 22.59 22 22.16 10978 20100707 IRM 22.28 23.07 22.2 23.06 13506 20100708 IRM 23.18 23.4 23.03 23.33 11271 20100709 IRM 23.36 23.56 23.19 23.52 11067 20100712 IRM 23.35 23.58 23.31 23.41 7307 20100713 IRM 23.64 24.1 23.6 24.02 9274 20100714 IRM 23.9 24.22 23.764 24.22 9346 20100715 IRM 24.21 24.28 23.81 24.21 8145 20100716 IRM 24.04 24.09 23.42 23.48 9016 20100719 IRM 23.51 23.72 23.1616 23.5 7717 20100720 IRM 23.07 24.07 23.07 24.06 8820 20100721 IRM 24.08 24.325 23.8832 24.11 15236 20100722 IRM 24.29 24.83 24.27 24.66 9875 20100723 IRM 24.64 25.12 24.54 25.1 9004 20100726 IRM 25.12 25.58 24.95 25.58 8247 20100727 IRM 25.68 25.68 25.35 25.5 17171 20100728 IRM 25.51 25.81 25.3 25.45 17890 20100729 IRM 25.01 25.35 23.93 24.06 24796 20100730 IRM 23.75 24.145 23.51 23.67 15659 20100802 IRM 23.93 24.41 23.79 24.37 12800 20100803 IRM 24.19 24.23 23.52 23.69 13885 20100804 IRM 23.69 23.775 23.42 23.61 15157 20100805 IRM 23.45 23.76 23.3087 23.52 9904 20100806 IRM 23.25 23.37 22.96 23.23 11346 20100809 IRM 23.31 23.41 23.24 23.35 11267 20100810 IRM 23.21 23.36 22.84 23.11 11517 20100811 IRM 22.84 22.84 22.28 22.28 8730 20100812 IRM 22.06 22.34 21.85 22.18 14478 20100813 IRM 22.13 22.2 21.97 21.97 8377 20100816 IRM 21.93 22.1 21.85 22 13622 20100817 IRM 22.18 22.275 21.98 22.01 17786 20100819 IRM 21.85 21.89 21.134 21.42 24342 20100820 IRM 21.22 21.59 - ---- - -15.44 15.3188 15.33 1040610 20091223 BAC 15.46 15.47 15.15 15.19 1021160 20091224 BAC 15.23 15.28 15.2 15.25 366117 20091228 BAC 15.31 15.41 15.15 15.29 1025732 20091229 BAC 15.3 15.33 15.1 15.12 830894 20091230 BAC 15.04 15.1 14.97 15.07 868978 20091231 BAC 15.09 15.24 15.01 15.06 943225 20100104 BAC 15.24 15.75 15.12 15.69 1808451 20100105 BAC 15.74 16.21 15.7 16.2 2095212 20100106 BAC 16.21 16.54 16.03 16.39 2052578 20100107 BAC 16.68 17.185 16.51 16.93 3208683 20100108 BAC 16.98 17.1 16.63 16.78 2201046 20100111 BAC 16.99 17.14 16.72 16.93 1689915 20100112 BAC 16.72 16.75 16.17 16.36 2234867 20100113 BAC 16.43 16.78 16.15 16.62 1926098 20100114 BAC 16.63 16.92 16.605 16.82 1429361 20100115 BAC 16.65 16.65 16.23 16.26 1952843 20100119 BAC 16.06 16.47 15.84 16.32 1816164 20100120 BAC 16.22 16.63 16.18 16.49 2887410 20100121 BAC 16.46 16.66 15.2 15.47 5512854 20100122 BAC 15.26 15.52 14.71 14.9 3696207 20100125 BAC 15.16 15.27 14.77 14.98 2623515 20100126 BAC 14.94 15.17 14.72 14.77 2123806 20100127 BAC 14.71 15.29 14.68 15.19 2587161 20100128 BAC 15.4 15.59 15.01 15.37 2328779 20100129 BAC 15.49 15.55 15.09 15.18 1751398 20100201 BAC 15.26 15.44 15.13 15.42 1595032 20100202 BAC 15.45 15.68 15.31 15.6 1715861 20100203 BAC 15.57 15.8 15.52 15.53 1308615 20100204 BAC 15.35 15.43 14.73 14.75 2525586 20100205 BAC 14.84 15.06 14.31 15 2976832 20100208 BAC 14.94 14.96 14.45 14.48 2082072 20100209 BAC 14.67 14.78 14.25 14.47 2515220 20100210 BAC 14.51 14.91 14.46 14.67 1757417 20100211 BAC 14.67 14.8 14.54 14.63 1410862 20100212 BAC 14.47 14.54 14.28 14.45 1628192 20100216 BAC 14.66 15.31 14.62 15.16 2054932 20100217 BAC 15.35 15.88 15.25 15.66 2615418 20100218 BAC 15.52 16 15.5 15.88 2421402 20100219 BAC 15.73 16.04 15.71 15.88 2161803 20100222 BAC 15.96 16.4 15.96 16.21 1737731 20100223 BAC 16.12 16.38 15.79 15.94 2104783 20100224 BAC 15.98 16.36 15.96 16.33 1915715 20100225 BAC 16.05 16.57 15.95 16.55 2873250 20100226 BAC 16.57 16.84 16.41 16.66 3436694 20100301 BAC 16.74 16.86 16.57 16.71 1709310 20100302 BAC 16.7 16.8 16.39 16.46 1830485 20100303 BAC 16.47 16.62 16.33 16.37 1549501 20100304 BAC 16.45 16.5 16.03 16.4 1577464 20100305 BAC 16.53 16.75 16.45 16.7 1724689 20100308 BAC 16.75 16.91 16.69 16.74 1277050 20100309 BAC 16.63 16.99 16.54 16.8 1677794 20100310 BAC 17.01 17.35 16.985 17.11 2229321 20100311 BAC 17.18 17.28 17.06 17.12 1450980 20100312 BAC 17.26 17.3 16.68 16.85 1714566 20100315 BAC 16.74 16.91 16.59 16.85 1203882 20100316 BAC 16.97 17.07 16.9 17.03 1074117 20100317 BAC 17.17 17.3 17.025 17.27 1344638 20100318 BAC 17.29 17.32 16.98 17.08 1239867 20100319 BAC 17.16 17.23 16.74 16.82 1782187 20100322 BAC 16.62 16.97 16.6 16.96 1136677 20100323 BAC 17.08 17.22 16.94 17.13 1312613 20100324 BAC 17.12 17.73 17.1 17.57 2708243 20100325 BAC 17.84 18.35 17.7 17.74 3153046 20100326 BAC 17.98 18.23 17.75 17.9 2209706 20100329 BAC 18.17 18.2 17.77 18.04 1525396 20100330 BAC 18.06 18.12 17.67 17.76 1443729 20100331 BAC 17.69 17.98 17.67 17.85 1142808 20100401 BAC 18.02 18.1 17.89 18.04 956072 20100405 BAC 18.17 18.25 18.02 18.13 1079892 20100406 BAC 18.16 18.54 18.1 18.49 1603165 20100407 BAC 18.58 18.86 18.53 18.62 2335222 20100408 BAC 18.59 18.84 18.31 18.65 1643054 20100409 BAC 18.82 18.85 18.5 18.59 1354805 20100412 BAC 18.68 18.82 18.6 18.66 1283189 20100413 BAC 18.61 18.72 18.49 18.67 1136877 20100414 BAC 18.98 19.42 18.92 19.4 2466246 20100415 BAC 19.63 19.8642 19.36 19.48 2400999 20100416 BAC 19.47 19.48 18.05 18.41 5890919 20100419 BAC 18.1 18.65 17.87 18.39 3588279 20100420 BAC 18.79 18.83 18.44 18.61 2005446 20100421 BAC 18.67 18.91 18.11 18.28 2021599 20100422 BAC 18.03 18.6 17.95 18.54 2194723 20100423 BAC 18.4 18.53 18.28 18.43 1454283 20100426 BAC 18.41 18.44 18.025 18.05 1608729 20100427 BAC 17.91 18.18 17.41 17.47 2594390 20100428 BAC 17.65 17.96 17.51 17.78 1952879 20100429 BAC 18.04 18.4 17.99 18.3 1772962 20100430 BAC 18.28 18.3 17.61 17.83 2315361 20100503 BAC 17.88 18.15 17.78 18.06 1507470 20100504 - ---- - -SBUX 25.99 26.1 24.88 25.01 189466 20100630 SBUX 24.91 25.31 24.27 24.3 169650 20100701 SBUX 24.45 24.75 23.678 24.66 157496 20100702 SBUX 24.69 24.79 24.11 24.35 84655 20100707 SBUX 23.6 24.45 23.52 24.4 90851 20100708 SBUX 24.47 24.93 24.39 24.84 104931 20100709 SBUX 24.84 25.34 24.84 25.3 70870 20100712 SBUX 25.3 25.52 24.978 25.27 64532 20100713 SBUX 25.57 26.07 25.47 25.94 79605 20100714 SBUX 25.86 26.15 25.75 26 59580 20100715 SBUX 26.02 26.18 25.64 26.13 62900 20100716 SBUX 26.07 26.44 25.27 25.35 97918 20100719 SBUX 25.35 25.71 25.08 25.49 72695 20100720 SBUX 25 25.7876 24.85 25.77 74257 20100721 SBUX 25.61 25.98 25.13 25.17 120653 20100722 SBUX 24.86 25.26 24.35 25.15 194232 20100723 SBUX 25.11 25.5 24.94 25.38 89468 20100726 SBUX 25.33 25.57 24.98 25.39 97510 20100727 SBUX 25.34 25.59 24.95 25.18 86000 20100728 SBUX 25.23 25.36 24.81 24.99 77161 20100729 SBUX 25.11 25.2 24.36 24.82 67063 20100730 SBUX 24.55 24.95 24.25 24.85 78412 20100802 SBUX 25.06 25.06 24.62 24.68 83369 20100803 SBUX 24.69 24.86 24.37 24.72 71889 20100805 SBUX 25.07 25.24 24.76 25.18 76722 20100806 SBUX 24.81 25.37 24.75 25.33 74908 20100809 SBUX 25.42 25.72 25.39 25.66 51787 20100810 SBUX 25.43 25.6 25.11 25.4 64512 20100811 SBUX 24.94 24.96 24.35 24.66 92258 20100812 SBUX 24.27 24.61 24.26 24.46 59819 20100813 SBUX 24.3 24.3725 23.95 23.99 60971 20100816 SBUX 23.8 24.15 23.668 23.82 73632 20100817 SBUX 23.9 24.59 23.84 24.295 70316 20100819 SBUX 24.34 24.524 23.86 24.04 68117 20100820 SBUX 24.04 24.11 23.76 24.05 54577 20090821 SCG 34.41 34.81 34.26 34.74 6378 20090824 SCG 34.78 34.89 34.67 34.83 7546 20090825 SCG 34.83 35.01 34.74 34.79 8620 20090826 SCG 34.79 34.89 34.64 34.86 7034 20090827 SCG 34.79 34.96 34.72 34.86 9150 20090828 SCG 35.1 35.1 34.72 34.95 6916 20090831 SCG 34.79 34.98 34.6 34.68 7958 20090901 SCG 34.6 35.02 34.47 34.74 12554 20090902 SCG 34.74 34.84 34.351 34.4 10935 20090903 SCG 34.6 34.6 34.09 34.39 7984 20090904 SCG 34.47 34.57 34.18 34.53 6709 20090909 SCG 34.35 34.38 34.07 34.23 8992 20090910 SCG 34.16 34.43 33.94 34.14 8730 20090911 SCG 34.14 34.21 33.8 33.86 7585 20090914 SCG 33.84 34.08 33.7 34.07 8986 20090915 SCG 34.12 34.24 33.975 34.11 10026 20090916 SCG 34.27 34.58 34 34.54 6714 20090917 SCG 34.54 34.77 34.41 34.44 8674 20090918 SCG 34.96 35.52 34.68 35.52 33757 20090921 SCG 35.3 35.63 35.05 35.3 9250 20090922 SCG 35.36 35.46 35 35.1 5939 20090923 SCG 35.23 35.68 35.08 35.21 6423 20090924 SCG 35.18 35.39 35.09 35.2 8199 20090925 SCG 35.15 35.28 35.04 35.17 10026 20090928 SCG 35.3 35.52 35.21 35.32 5672 20090929 SCG 35.43 35.48 35.14 35.3 6178 20090930 SCG 35.3 35.311 34.67 34.9 11417 20091001 SCG 34.58 34.98 34.5 34.5 6318 20091002 SCG 34.34 34.51 33.99 34.09 11062 20091005 SCG 34.23 34.57 33.94 34.53 7946 20091006 SCG 34.79 34.81 34.46 34.66 7707 20091007 SCG 34.67 34.68 34.43 34.64 4817 20091008 SCG 34.79 34.8 34.6 34.68 4085 20091009 SCG 34.7 34.82 34.63 34.82 2458 20091012 SCG 34.78 35.2 34.776 34.99 3687 20091013 SCG 34.91 34.91 34.685 34.73 5238 20091014 SCG 34.92 34.9956 34.67 34.85 3828 20091015 SCG 34.86 35.27 34.69 35.19 7105 20091016 SCG 34.93 35.18 34.66 34.85 14078 20091019 SCG 34.83 35.77 34.76 35.68 8284 20091020 SCG 35.64 35.69 35.2 35.35 4401 20091021 SCG 35.38 35.54 35.11 35.12 8269 20091022 SCG 35.22 35.39 34.96 35.34 8962 20091023 SCG 35.37 35.55 34.77 34.96 6617 20091026 SCG 35.05 35.44 34.54 34.59 6881 20091027 SCG 35.77 35.77 34.15 34.7 7588 20091028 SCG 34.64 34.699 34.24 34.32 13004 20091105 SCG 34.06 34.26 33.81 34.23 6635 20091106 SCG 34.2 34.31 33.91 34.15 7332 20091109 SCG 34.35 34.69 34.2 34.68 5069 20091110 SCG 34.7 34.96 34.62 34.95 8391 20091111 SCG 34.96 35.06 34.52 34.69 8534 20091112 SCG 34.68 34.76 34.17 34.23 6779 20091113 SCG 34.37 34.61 34.21 34.5 8672 20091116 SCG 34.65 35.03 34.5 35 7517 20091117 SCG 35.11 35.13 34.9 35.13 8279 20091118 SCG 35.12 35.13 34.8 34.84 6074 20091119 SCG 34.69 34.69 34.22 34.43 5447 20091120 SCG 34.37 34.64 34.28 34.62 7824 20091123 SCG 34.73 - ---- - -20091201 AMAT 12.43 12.95 12.4 12.89 332354 20091202 AMAT 12.88 13.0775 12.84 13 180437 20091203 AMAT 13.07 13.27 13.04 13.07 177815 20091204 AMAT 13.26 13.56 13.05 13.32 200643 20091207 AMAT 13.26 13.515 13.23 13.25 195194 20091208 AMAT 13.19 13.4 13.02 13.32 176929 20091209 AMAT 13.24 13.49 13.14 13.49 172993 20091210 AMAT 13.49 13.64 13.27 13.31 181459 20091211 AMAT 13.4 13.57 13.21 13.38 128189 20091214 AMAT 13.53 13.59 13.31 13.56 144259 20091215 AMAT 13.47 13.71 13.44 13.53 130251 20091216 AMAT 13.57 13.99 13.53 13.59 291171 20091217 AMAT 13.49 13.6 13.35 13.35 119600 20091218 AMAT 13.41 13.63 13.34 13.62 192396 20091221 AMAT 13.77 13.86 13.72 13.84 125594 20091222 AMAT 13.91 14.05 13.88 13.94 139393 20091223 AMAT 14.07 14.22 13.91 13.95 168989 20091224 AMAT 13.99 14.01 13.93 14 56635 20091228 AMAT 14.04 14.07 13.75 13.86 91901 20091229 AMAT 13.83 13.93 13.71 13.74 74504 20091230 AMAT 13.72 14.1 13.7 14.06 102158 20091231 AMAT 14.05 14.14 13.92 13.94 90303 20100104 AMAT 14.03 14.57 14.03 14.3 186159 20100105 AMAT 14.23 14.38 14.04 14.19 151737 20100106 AMAT 14.2 14.4 14.1 14.16 137049 20100107 AMAT 14.13 14.21 13.96 14.01 215495 20100108 AMAT 14.24 14.59 14.11 14.552 412148 20100111 AMAT 14.84 14.94 14.45 14.87 336715 20100112 AMAT 14.75 14.77 14.03 14.2 403508 20100113 AMAT 14.28 14.42 13.92 14.27 251382 20100114 AMAT 14.25 14.38 14.02 14.35 269335 20100115 AMAT 14.34 14.34 13.67 13.73 360347 20100119 AMAT 13.78 14.02 13.75 13.97 146214 20100120 AMAT 13.82 13.89 13.65 13.8 192211 20100121 AMAT 13.83 14.09 13.5205 13.58 252659 20100122 AMAT 13.36 13.39 12.61 12.63 481068 20100125 AMAT 12.67 12.94 12.59 12.64 397672 20100126 AMAT 12.75 13.01 12.64 12.65 369024 20100127 AMAT 12.75 13.07 12.69 13.04 304517 20100128 AMAT 13.07 13.09 12.35 12.61 350246 20100129 AMAT 12.8 12.85 12.15 12.18 256020 20100201 AMAT 12.32 12.56 12.23 12.52 202272 20100202 AMAT 12.58 12.59 12.35 12.51 215259 20100203 AMAT 12.36 12.48 12.12 12.28 361704 20100204 AMAT 12.15 12.22 11.66 11.8 407373 20100205 AMAT 11.82 12.27 11.68 12.23 437839 20100208 AMAT 12.2 12.33 12.03 12.07 179763 20100209 AMAT 12.29 12.4 12.04 12.15 211236 20100210 AMAT 12.23 12.315 12.1 12.23 172146 20100211 AMAT 12.21 12.53 12.06 12.47 183881 20100212 AMAT 12.32 12.72 12.15 12.47 237485 20100216 AMAT 12.67 12.97 12.56 12.95 216265 20100217 AMAT 13.09 13.15 12.75 12.99 252025 20100218 AMAT 12.78 12.79 12.31 12.68 452122 20100219 AMAT 12.64 12.64 12.35 12.5 290927 20100222 AMAT 12.53 12.585 12.39 12.45 226976 20100223 AMAT 12.46 12.48 11.94 12.01 302387 20100224 AMAT 12.08 12.42 12.05 12.27 256254 20100225 AMAT 12.05 12.25 11.94 12.22 217504 20100226 AMAT 12.27 12.3 12.03 12.24 158825 20100301 AMAT 12.3 12.5 12.29 12.5 164653 20100302 AMAT 12.55 12.64 12.35 12.42 224294 20100303 AMAT 12.46 12.55 12.34 12.39 170311 20100304 AMAT 12.4 12.48 12.09 12.26 274248 20100305 AMAT 12.34 12.43 12.23 12.29 239940 20100308 AMAT 12.52 12.53 12.31 12.36 297156 20100309 AMAT 12.3 12.415 12.24 12.29 245629 20100310 AMAT 12.26 12.55 12.26 12.53 351190 20100311 AMAT 12.48 12.52 12.28 12.41 305945 20100312 AMAT 12.52 12.55 12.3 12.36 250698 20100315 AMAT 12.33 12.33 12.12 12.23 236612 20100316 AMAT 12.25 12.49 12.2 12.45 297958 20100317 AMAT 12.5 12.69 12.45 12.66 277777 20100318 AMAT 12.7 12.77 12.53 12.63 186893 20100319 AMAT 12.71 12.71 12.37 12.49 247673 20100322 AMAT 12.43 12.82 12.39 12.78 262570 20100323 AMAT 12.83 13.32 12.8 13.235 396508 20100324 AMAT 13.17 13.23 12.91 13 341346 20100325 AMAT 13.15 13.38 13.09 13.16 382806 20100326 AMAT 13.27 13.45 13.01 13.21 300929 20100329 AMAT 13.23 13.45 13.22 13.31 278288 20100330 AMAT 13.35 13.6 13.23 13.45 393648 20100331 AMAT 13.44 13.75 13.43 13.4675 408143 20100401 AMAT 13.63 13.73 13.2666 13.35 371164 20100405 AMAT 13.42 13.61 13.37 13.52 293320 20100406 AMAT 13.49 13.555 13.39 13.48 164524 20100407 AMAT 13.45 13.71 13.37 13.58 208716 20100408 AMAT 13.5 13.5 13.3 13.34 291794 20100409 AMAT 13.35 13.47 13.31 13.465 154474 20100412 AMAT 13.49 13.74 - ---- - -5.845 5.36 5.77 83804 20100512 NOVL 5.8 5.83 5.63 5.75 56592 20100513 NOVL 5.73 6.06 5.715 5.86 78830 20100514 NOVL 5.81 5.905 5.75 5.84 53196 20100517 NOVL 5.81 5.91 5.74 5.88 66451 20100518 NOVL 5.9 5.95 5.8 5.82 64876 20100519 NOVL 5.81 6.08 5.8 6.03 84049 20100520 NOVL 6.03 6.06 5.87 5.91 80917 20100521 NOVL 5.79 6 5.75 6 48472 20100524 NOVL 6 6.015 5.92 5.94 16129 20100525 NOVL 5.77 5.92 5.75 5.91 45496 20100526 NOVL 5.86 5.96 5.8 5.81 43456 20100527 NOVL 5.88 5.91 5.83 5.9 28026 20100528 NOVL 5.9 5.93 5.83 5.83 31402 20100601 NOVL 5.82 5.85 5.75 5.76 26740 20100602 NOVL 5.78 5.9 5.77 5.85 24114 20100603 NOVL 5.85 6.05 5.8101 6.03 31653 20100604 NOVL 5.86 5.98 5.85 5.9 36681 20100607 NOVL 5.9 5.98 5.89 5.96 50094 20100608 NOVL 5.96 6 5.91 5.98 59189 20100609 NOVL 6 6 5.89 5.89 42043 20100610 NOVL 6.02 6.1 5.94 6.09 26497 20100611 NOVL 6.01 6.27 6.01 6.26 73032 20100614 NOVL 6.22 6.36 6.14 6.19 65685 20100615 NOVL 6.16 6.26 6.16 6.24 22522 20100616 NOVL 6.2 6.24 6.09 6.16 22683 20100617 NOVL 6.16 6.18 6.05 6.12 18111 20100618 NOVL 6.1 6.15 6.07 6.12 31903 20100621 NOVL 6.14 6.15 5.97 6.01 23041 20100622 NOVL 6.01 6.1 5.96 5.99 24027 20100623 NOVL 6.02 6.05 5.89 6.01 23495 20100624 NOVL 5.99 6.02 5.9 5.95 27858 20100625 NOVL 5.96 6.07 5.91 5.9475 59960 20100628 NOVL 5.95 6.03 5.925 5.94 14546 20100629 NOVL 5.84 5.88 5.72 5.76 35739 20100630 NOVL 5.79 5.86 5.65 5.68 40950 20100701 NOVL 5.7 5.9 5.69 5.82 53842 20100702 NOVL 5.84 5.97 5.84 5.91 37194 20100706 NOVL 5.95 5.965 5.78 5.84 35468 20100707 NOVL 5.88 5.89 5.81 5.89 29997 20100708 NOVL 5.85 5.98 5.84 5.98 45064 20100709 NOVL 5.95 6.06 5.88 6.06 23943 20100712 NOVL 6.02 6.15 5.98 6.14 31232 20100713 NOVL 6.17 6.2 6.13 6.2 35631 20100714 NOVL 6.15 6.18 6.1 6.15 34348 20100715 NOVL 6.13 6.195 6.08 6.18 28040 20100716 NOVL 6.12 6.2 6.07 6.1 32119 20100719 NOVL 6.1 6.21 6.02 6.17 40151 20100720 NOVL 6.125 6.2 6 6.17 33421 20100721 NOVL 6.16 6.18 6 6.01 12484 20100722 NOVL 6.11 6.16 6.05 6.11 15581 20100723 NOVL 6.12 6.19 6.1 6.16 10588 20100726 NOVL 6.16 6.2 6.13 6.2 20392 20100727 NOVL 6.19 6.2 6.14 6.2 15814 20100728 NOVL 6.16 6.19 6.02 6.12 19101 20100729 NOVL 6.14 6.14 5.98 5.98 27560 20100730 NOVL 5.98 6.04 5.94 6.04 28064 20100802 NOVL 6.09 6.12 6.02 6.09 14096 20100803 NOVL 6.08 6.09 5.99 6.05 14004 20100804 NOVL 6.05 6.11 5.97 6.11 18282 20100806 NOVL 6.05 6.12 6 6.08 19371 20100809 NOVL 6.08 6.1 5.98 6.01 16316 20100810 NOVL 5.87 6 5.75 5.82 98531 20100811 NOVL 5.73 5.76 5.54 5.59 105436 20100812 NOVL 5.54 5.65 5.52 5.535 60669 20100813 NOVL 5.57 5.69 5.53 5.68 33596 20100816 NOVL 5.63 5.85 5.61 5.8 30466 20100817 NOVL 5.87 5.94 5.825 5.93 30724 20100819 NOVL 5.87 5.94 5.73 5.77 19563 20100820 NOVL 5.75 5.86 5.73 5.81 29790 20100201 NRG 24.15 24.23 23.56 23.9 65175 20100202 NRG 23.89 23.89 23.39 23.56 63730 20100203 NRG 23.42 23.55 23.05 23.11 39935 20100204 NRG 23 23 22.045 22.1 55791 20100205 NRG 22.09 22.13 21.38 21.71 58255 20100208 NRG 21.74 22.01 21.56 21.59 37852 20100209 NRG 21.86 22.27 21.74 21.89 43630 20100210 NRG 21.9 21.91 21.34 21.66 35605 20100211 NRG 21.95 22.28 21.68 22.22 45361 20100212 NRG 22.05 22.07 21.65 22.06 40441 20100216 NRG 22.13 22.49 22.1 22.49 26898 20100217 NRG 22.55 22.76 22.41 22.59 34664 20100218 NRG 22.41 22.65 22.28 22.57 43483 20100219 NRG 22.59 23.45 22.44 23.2 51922 20100222 NRG 23.42 23.52 23.05 23.07 39919 20100223 NRG 22.5 22.88 22.2 22.26 51587 20100224 NRG 22.33 22.5 21.57 21.86 55363 20100225 NRG 21.42 22.13 21.36 22.07 51948 20100226 NRG 22.11 22.24 21.6 21.84 50763 20100301 NRG 21.89 22.66 21.88 22.58 44542 20100302 NRG 22.66 22.965 22.64 22.67 53423 20100303 NRG 22.74 22.98 22.48 22.5 41670 20100304 NRG 22.41 22.43 22 22.3 56326 20100305 NRG 22.34 23.02 22.34 22.82 46656 20100308 NRG 22.8 23.03 22.7 22.9 18574 20100309 NRG 22.83 22.98 22.72 22.75 24259 20100310 NRG 22.7 22.83 22.56 22.64 28476 20100311 NRG 22.56 22.94 22.52 22.94 28327 20100312 NRG 22.73 22.88 22.07 22.19 52320 20100315 NRG 22.16 22.35 22.02 22.27 - ---- - -14.61 14.87 1540554 20090910 GE 14.92 14.94 14.52 14.8 1198800 20090911 GE 14.87 14.98 14.63 14.67 1012190 20090914 GE 14.55 15.41 14.4 15.35 1392840 20090915 GE 15.49 16.15 15.48 16 2091985 20090916 GE 16.39 17.18 16.33 17 2689680 20090917 GE 16.97 17.52 16.35 16.66 2550665 20090918 GE 16.88 16.88 16.43 16.5 1230240 20090921 GE 16.43 16.89 16.24 16.76 1092990 20090922 GE 17.06 17.19 16.91 17.01 959104 20090923 GE 17.17 17.5 16.95 17 1344096 20090924 GE 17.06 17.17 16.34 16.58 1232292 20090925 GE 16.35 16.57 16.06 16.37 1037357 20090928 GE 16.47 16.91 16.44 16.76 737865 20090929 GE 16.91 17.09 16.67 16.71 807781 20090930 GE 16.83 16.86 16.31 16.42 1207635 20091001 GE 16.31 16.39 15.95 15.97 1134940 20091002 GE 15.45 15.66 15.15 15.36 1330917 20091005 GE 15.59 15.91 15.51 15.83 739009 20091006 GE 16.14 16.4001 16 16.08 956979 20091007 GE 16.03 16.32 15.91 16.16 609114 20091008 GE 16.46 16.55 16.2 16.22 773694 20091009 GE 16.2 16.37 16.1 16.18 704068 20091012 GE 16.36 16.49 16.27 16.33 586272 20091013 GE 16.32 16.54 16.08 16.39 706429 20091014 GE 16.77 16.87 16.56 16.84 925694 20091015 GE 16.79 16.84 16.48 16.79 923288 20091016 GE 16.35 16.41 15.85 16.08 1823347 20091019 GE 16.05 16.13 15.8 15.84 992456 20091020 GE 15.8 15.82 15.47 15.58 1010874 20091021 GE 15.51 15.95 15.5 15.53 966835 20091022 GE 15.5 15.58 15.11 15.34 1251213 20091023 GE 15.37 15.4 15.11 15.2 880866 20091026 GE 15.24 15.45 14.83 15.01 962708 20091027 GE 15.07 15.14 14.86 14.93 874651 20091028 GE 14.77 14.82 14.35 14.42 1072727 20091105 GE 14.28 14.55 14.21 14.43 705440 20091106 GE 14.98 15.49 14.83 15.33 1650533 20091109 GE 15.7 15.92 15.6 15.85 1029088 20091110 GE 15.95 15.99 15.48 15.78 736000 20091111 GE 15.94 15.97 15.65 15.83 712973 20091112 GE 15.8 15.94 15.66 15.75 656096 20091113 GE 15.76 15.8 15.56 15.66 654318 20091116 GE 15.8 16.19 15.77 16 982478 20091117 GE 15.96 16.08 15.89 16.02 520384 20091118 GE 16.01 16.14 15.95 16.09 475687 20091119 GE 15.92 15.96 15.5741 15.76 697712 20091120 GE 15.66 15.72 15.45 15.59 639159 20091123 GE 15.83 16.04 15.83 16.02 739054 20091124 GE 16.08 16.2 15.92 16.12 807053 20091125 GE 16.24 16.25 16.0377 16.18 481709 20091127 GE 15.49 16.08 15.3 15.94 609175 20091130 GE 15.82 16.06 15.81 16.02 701684 20091201 GE 16.27 16.35 15.96 16.17 980342 20091202 GE 16.12 16.22 15.96 16.07 653246 20091203 GE 16.12 16.31 16 16 745557 20091204 GE 16.34 16.49 16.06 16.2 884109 20091207 GE 16.07 16.24 16.01 16.08 644173 20091208 GE 15.9 15.93 15.65 15.72 788521 20091209 GE 15.73 15.79 15.52 15.66 586965 20091210 GE 15.81 15.85 15.55 15.61 557820 20091211 GE 15.72 16 15.69 15.92 564486 20091214 GE 15.98 16.07 15.92 15.95 438574 20091215 GE 15.83 16.021 15.65 15.75 792412 20091216 GE 15.8 15.85 15.66 15.69 725444 20091217 GE 15.59 15.95 15.55 15.79 682736 20091218 GE 15.91 15.91 15.587 15.59 792024 20091221 GE 15.69 15.79 15.535 15.57 531453 20091222 GE 15.57 15.69 15.43 15.48 481672 20091223 GE 15.46 15.48 15.31 15.41 423407 20091224 GE 15.38 15.48 15.36 15.44 185801 20091228 GE 15.38 15.43 15.26 15.34 457447 20091229 GE 15.36 15.53 15.3 15.44 483941 20091230 GE 15.31 15.37 15.26 15.35 449500 20091231 GE 15.27 15.34 15.13 15.13 445315 20100104 GE 15.22 15.64 15.15 15.45 670798 20100105 GE 15.46 15.67 15.45 15.53 645505 20100106 GE 15.53 15.62 15.44 15.45 554648 20100107 GE 15.48 16.48 15.43 16.25 1854722 20100108 GE 16.31 16.69 16.27 16.6 1151125 20100111 GE 16.83 16.88 16.54 16.76 766753 20100112 GE 16.58 16.835 16.57 16.77 646227 20100113 GE 16.76 16.92 16.57 16.83 653423 20100114 GE 16.79 16.87 16.68 16.7 573808 20100115 GE 16.68 16.75 16.35 16.44 741235 20100119 GE 16.35 16.75 16.34 16.54 606973 20100120 GE 16.5 16.6817 16.33 16.5 644955 20100121 GE 16.47 16.48 15.95 16.02 991511 20100122 GE 16.55 16.76 16.09 16.11 1626776 20100125 GE 16.46 16.53 16.22 16.37 751603 20100126 GE 16.33 16.7 16.26 16.35 780268 20100127 GE 16.29 16.39 16.03 16.3 768505 20100128 GE 16.43 16.45 16.01 16.16 791626 20100129 GE 16.22 16.5 16.07 16.08 811615 - ---- - -20.62 20.78 10548 20100303 SEE 20.82 20.9 20.73 20.85 9386 20100304 SEE 20.81 20.9 20.31 20.53 14691 20100305 SEE 20.73 20.94 20.62 20.91 12077 20100308 SEE 20.93 21.14 20.74 20.88 13096 20100309 SEE 20.77 20.82 20.57 20.7 16633 20100310 SEE 20.69 20.98 20.46 20.84 17465 20100311 SEE 20.76 20.89 20.61 20.86 5664 20100312 SEE 21.01 21.16 20.9 21.1 9363 20100315 SEE 21.11 21.19 20.96 21.18 8626 20100316 SEE 21.19 21.5 21.18 21.48 11478 20100317 SEE 21.48 21.76 21.39 21.71 11241 20100318 SEE 21.75 21.81 21.64 21.74 10791 20100319 SEE 21.75 22.1 21.5 21.6 13045 20100322 SEE 21.53 21.83 21.44 21.75 10852 20100323 SEE 21.73 21.77 21.515 21.74 11041 20100324 SEE 21.68 21.69 21.46 21.47 8852 20100325 SEE 21.63 21.75 21.28 21.28 15270 20100326 SEE 21.33 21.56 21.14 21.31 9253 20100329 SEE 21.32 21.56 21.16 21.28 12882 20100330 SEE 21.27 21.39 21.15 21.38 12731 20100331 SEE 21.28 21.38 21.06 21.08 10792 20100401 SEE 21.29 21.53 21.181 21.33 10745 20100405 SEE 21.45 21.71 21.34 21.7 6353 20100406 SEE 21.67 21.79 21.55 21.76 12145 20100407 SEE 21.68 21.87 21.45 21.51 15145 20100408 SEE 21.42 21.69 21.29 21.67 10183 20100409 SEE 21.7 21.753 21.55 21.7 8425 20100412 SEE 21.73 21.8 21.39 21.49 9439 20100413 SEE 21.43 21.51 21.19 21.48 10442 20100414 SEE 21.5 22.13 21.5 22.13 15940 20100415 SEE 22.16 22.7 22.02 22.7 19871 20100416 SEE 22.73 22.86 22.35 22.45 23972 20100419 SEE 22.32 22.59 22.265 22.56 13149 20100420 SEE 22.64 22.99 22.585 22.94 13518 20100421 SEE 23.02 23.41 22.96 23.08 15170 20100422 SEE 22.97 23.21 22.76 23.2 9839 20100423 SEE 23.17 23.36 23.02 23.26 9332 20100426 SEE 23.32 23.43 23 23.13 12424 20100427 SEE 23.03 23.18 22.72 22.76 23438 20100428 SEE 22.96 23.18 21.95 22.3 28046 20100429 SEE 22.38 22.47 22.04 22.29 11326 20100430 SEE 22.37 22.49 21.45 21.5 18685 20100503 SEE 21.64 21.71 21.35 21.68 16739 20100504 SEE 21.41 21.65 21.28 21.51 20412 20100505 SEE 21.34 21.75 21.18 21.44 15534 20100506 SEE 21.31 21.49 19.32 20.68 19123 20100507 SEE 20.6 20.95 20.16 20.58 25939 20100510 SEE 21.49 21.61 21.22 21.46 11355 20100511 SEE 21.27 21.41 21.02 21.05 13522 20100512 SEE 21.06 21.42 21.02 21.37 7641 20100513 SEE 21.34 21.75 21.12 21.54 14044 20100514 SEE 21.44 21.5 21 21.14 13989 20100517 SEE 21.3 22.82 21.3 22.32 30945 20100518 SEE 22.41 22.53 21.545 21.55 19280 20100519 SEE 21.47 21.79 21.32 21.72 17304 20100520 SEE 21.17 21.29 20.63 20.63 15561 20100521 SEE 20.47 20.98 20.04 20.96 21129 20100524 SEE 20.78 20.89 20.51 20.58 14392 20100525 SEE 20.13 20.62 19.83 20.62 14028 20100526 SEE 20.77 20.91 20.4 20.47 14405 20100527 SEE 20.89 21.08 20.53 21.07 13659 20100528 SEE 21.07 21.12 20.72 20.84 9441 20100601 SEE 20.6 20.875 20.24 20.27 10846 20100602 SEE 20.25 20.65 20.14 20.64 8166 20100603 SEE 20.71 20.87 20.59 20.83 9362 20100604 SEE 20.44 20.72 20.02 20.11 14346 20100607 SEE 20.11 20.18 19.87 19.96 15928 20100608 SEE 19.93 20.15 19.71 20.07 22483 20100609 SEE 20.18 20.41 19.99 20.22 18349 20100610 SEE 20.52 20.75 20.3 20.6 11011 20100611 SEE 20.39 20.91 20.3301 20.85 11273 20100614 SEE 21.05 21.31 20.87 20.93 8214 20100615 SEE 21.03 21.34 21.03 21.34 10063 20100616 SEE 21.13 21.32 21.01 21.18 8520 20100617 SEE 21.27 21.38 21.09 21.37 9072 20100618 SEE 21.45 21.54 21.36 21.52 10151 20100621 SEE 21.83 21.86 21.22 21.4 8803 20100622 SEE 21.41 21.5 20.9 20.93 6141 20100623 SEE 20.92 21.09 20.65 20.89 8460 20100624 SEE 20.87 21.14 20.6 20.65 7646 20100625 SEE 20.69 20.81 20.42 20.69 8726 20100628 SEE 20.7 20.79 20.39 20.43 7625 20100629 SEE 20.16 20.39 19.9 20 13331 20100630 SEE 19.94 20.09 19.62 19.72 17337 20100701 SEE 19.74 19.83 19.28 19.59 10788 20100702 SEE 19.65 19.66 19.34 19.49 8319 20100706 SEE 19.7 19.86 19.48 19.77 20966 20100707 SEE 19.84 20.32 19.73 20.32 12596 20100708 SEE 20.44 20.69 20.31 20.68 9374 20100709 SEE 20.8 20.93 20.68 20.85 6287 20100712 SEE 20.85 21.2 20.81 20.86 7326 20100713 SEE 21.02 21.63 21.02 21.57 9073 20100714 SEE 21.49 21.64 21.29 21.58 8212 20100715 SEE 21.6 21.87 21.47 21.81 10734 20100716 - ---- - -SII 48.55 49.66 48.21 48.83 201169 20100430 SII 49.03 49.2 46.6 47.76 170794 20100503 SII 47.76 48.29 46.94 47.76 115480 20100504 SII 46.71 47.47 45.9 46.15 71278 20100505 SII 45.12 45.92 44.39 45.15 80377 20100506 SII 45.06 45.77 40.63 43.65 101066 20100507 SII 43.4 43.97 41.47 41.88 107612 20100510 SII 43.9 44.96 43.78 44.87 102878 20100511 SII 44.27 45.6 44.21 44.75 63254 20100512 SII 45.08 45.26 43.95 44.75 35583 20100513 SII 44.94 45.85 44.21 44.84 41928 20100514 SII 44.55 44.66 42.94 43.54 46048 20100517 SII 43.36 43.89 41.9 43.02 50234 20100518 SII 43.6 44.34 42.62 42.88 57255 20100519 SII 42.63 43.35 41.4 41.95 72350 20100520 SII 40.69 40.91 39.39 39.4 130123 20100521 SII 39.04 40.46 38.56 40.36 99756 20100524 SII 40.24 40.37 38.24 38.31 63781 20100525 SII 37.25 39.19 37.08 39.06 72943 20100526 SII 39.6 40.4 39.15 39.28 50084 20100527 SII 40.29 40.87 39.33 40.17 66717 20100528 SII 39.75 39.89 37.19 37.56 93961 20100601 SII 36.55 36.73 34.44 34.45 112343 20100602 SII 35.56 37.75 35.42 37.7 72736 20100603 SII 38.39 38.46 36.47 37.97 77320 20100604 SII 37.38 38.82 37.04 37.38 68191 20100607 SII 37.5 38.04 36.35 36.48 49741 20100608 SII 36.54 37.62 36.1503 37.52 75278 20100609 SII 38.01 39.15 37.19 37.35 61712 20100610 SII 38.85 40.15 38.78 40.09 45155 20100611 SII 39.43 40.35 39.35 40.23 51751 20100614 SII 40.9 41.18 39.56 39.68 58830 20100615 SII 40.33 41.35 40 41.23 32753 20100616 SII 40.44 41.75 40.44 41.15 36536 20100617 SII 41.5 41.7 40.96 41.49 49642 20100618 SII 41.44 41.46 40.28 41.18 52741 20100621 SII 41.96 42.03 40.63 41 30748 20100622 SII 41.06 41.23 39.55 39.62 67036 20100623 SII 39.54 40.01 39.06 39.68 49378 20100624 SII 39.43 39.74 38.75 38.82 43387 20100625 SII 38.96 39.92 38.63 39.47 84600 20100628 SII 39.54 39.7 38.91 39.07 43451 20100629 SII 37.92 38.48 37.35 37.47 57438 20100630 SII 37.58 38.58 37.47 37.65 50216 20100701 SII 37.79 38.09 36.51 37.73 59021 20100702 SII 37.79 38.33 37.02 37.52 37419 20100706 SII 38.65 38.77 37.3 37.9 47646 20100707 SII 37.93 39.33 37.88 39.3 57649 20100708 SII 39.71 40.05 39.015 40.05 39819 20100709 SII 40.08 40.27 39.59 40.06 24511 20100712 SII 40.05 40.4 39.45 39.99 28168 20100713 SII 40.59 40.98 40.24 40.33 26533 20100714 SII 39.94 40.8625 39.81 40.38 34156 20100715 SII 40.24 40.43 39.42 40.29 48777 20100716 SII 40.06 40.16 39.11 39.15 132872 20100719 SII 39.78 41.26 39.59 40.92 74264 20100720 SII 40.38 42.41 40.135 42.22 66690 20100721 SII 42.39 42.55 40.75 41.17 59273 20100722 SII 41.93 42.84 41.69 42.38 49300 20100723 SII 40.985 41.5 40.3 41.06 57465 20100726 SII 41.26 41.27 40 40.73 35759 20100727 SII 40.92 41.11 39.88 40.85 58052 20100728 SII 40.78 41.725 40.69 41.43 47063 20100729 SII 41.81 42.36 40.785 41.59 47115 20100730 SII 40.97 41.68 40.8 41.48 32061 20100802 SII 42.41 44.02 42.3 43.61 65610 20100803 SII 43.04 44.01 42.95 43.68 46229 20100804 SII 43.76 44.25 43.31 43.68 28656 20100805 SII 43.43 43.95 43.05 43.88 22383 20100806 SII 43.46 43.98 42.68 43.35 28624 20100809 SII 43.71 43.88 43.35 43.58 22249 20100810 SII 42.82 43.44 42.51 43.23 35942 20100811 SII 42.28 42.42 41.43 41.73 50995 20100812 SII 41.02 41.61 40.72 41.17 45494 20100813 SII 40.94 41.56 40.8 40.82 23310 20100816 SII 40.63 41.57 40.57 41.26 27031 20100817 SII 41.76 42.4 41.46 42 19835 20100819 SII 40.93 41.26 39.87 40.17 34647 20100820 SII 39.77 39.94 38.82 39.24 26736 20090821 SJM 53.95 55.36 53.56 54.1 25558 20090824 SJM 54.3 54.58 52.84 53.16 10239 20090825 SJM 53.27 53.47 52.33 52.47 10640 20090826 SJM 52.63 52.7 51.73 51.9 9859 20090827 SJM 51.69 52.04 51.33 51.92 6721 20090828 SJM 51.88 52.45 51.69 51.9 8013 20090831 SJM 51.85 52.28 51.7 52.27 7378 20090901 SJM 52.24 52.28 51.11 51.33 8495 20090902 SJM 51.31 51.75 51.12 51.46 6023 20090903 SJM 51.57 51.69 50.9 51.59 13103 20090904 SJM 51.27 51.75 51 51.73 6047 20090909 SJM 53.06 53.86 52.82 53.12 11721 20090910 SJM 53.2 53.44 52.49 53.44 9989 20090911 SJM 53.61 54 53.32 53.84 7280 20090914 SJM 53.62 53.62 53.14 53.34 6518 20090915 SJM - ---- - -24.5 24.73 8359 20091124 IRM 24.78 24.78 24.3738 24.62 9942 20091125 IRM 24.7 24.88 24.65 24.81 7482 20091127 IRM 24.43 24.73 24.14 24.52 5494 20091130 IRM 24.44 24.54 23.91 24 14591 20091201 IRM 24.23 24.26 23.9 24 13476 20091202 IRM 24.04 24.39 23.9 24.05 22559 20091203 IRM 24.02 24.1937 23.75 23.77 8947 20091204 IRM 23.98 24.2 23.76 24 12357 20091207 IRM 24.08 24.08 23.68 23.84 14995 20091208 IRM 23.76 23.76 23.24 23.35 16290 20091209 IRM 23.29 23.44 23.05 23.41 12163 20091210 IRM 23.43 23.72 23.42 23.62 9741 20091211 IRM 23.64 23.93 23.55 23.81 5790 20091214 IRM 23.87 24.08 23.76 23.89 8386 20091215 IRM 23.78 23.9 23.58 23.66 7628 20091216 IRM 23.68 23.83 23.445 23.53 8548 20091217 IRM 23.46 23.56 23.17 23.18 8225 20091218 IRM 23.19 23.36 22.82 23.17 16780 20091221 IRM 23.35 23.59 23.3 23.4 5955 20091222 IRM 23.42 23.56 23.4 23.53 7276 20091223 IRM 23.45 23.53 23.26 23.39 5740 20091224 IRM 23.49 23.49 23.34 23.41 2059 20091228 IRM 23.4 23.5 23.19 23.23 3680 20091229 IRM 23.34 23.4 23.18 23.23 6378 20091230 IRM 23.23 23.31 22.89 23 9016 20091231 IRM 23.12 23.29 22.74 22.76 6384 20100104 IRM 22.87 23.06 22.68 22.89 9200 20100105 IRM 22.83 23.03 22.7 22.96 10352 20100106 IRM 22.99 23.77 22.94 23.7 18252 20100107 IRM 23.68 24.08 23.61 24.08 14037 20100108 IRM 24 24.23 23.83 24.15 9690 20100111 IRM 24.2 24.4 23.99 24.33 9372 20100112 IRM 24.14 24.43 23.95 24.04 14838 20100113 IRM 24.09 24.68 24.09 24.66 9263 20100114 IRM 24.65 24.86 24.36 24.83 11219 20100115 IRM 24.75 24.93 24.25 24.38 11656 20100119 IRM 24.35 24.81 24.26 24.73 8862 20100120 IRM 24.53 24.56 24.16 24.3 6295 20100121 IRM 24.26 24.44 24.02 24.07 13113 20100122 IRM 24.08 24.11 23.71 23.74 14418 20100125 IRM 23.92 23.96 23.4 23.57 8371 20100126 IRM 23.54 23.65 23.19 23.2 7713 20100127 IRM 23.18 23.35 22.91 23.21 11918 20100128 IRM 23.26 23.26 22.8 22.9 7251 20100129 IRM 23.09 23.2 22.82 22.86 14834 20100201 IRM 22.97 23.135 22.86 22.98 9382 20100202 IRM 22.98 23.28 22.9 23.23 9856 20100203 IRM 23.15 23.43 23.05 23.11 8078 20100204 IRM 22.86 23.06 22.58 22.59 13856 20100205 IRM 22.51 22.75 21.95 22.1 27247 20100208 IRM 22.08 22.12 21.8 21.8 12296 20100209 IRM 22.04 22.18 21.78 21.94 11567 20100210 IRM 21.94 22.05 21.5 21.62 15762 20100211 IRM 21.58 21.92 21.32 21.73 17130 20100212 IRM 21.6 21.78 21.38 21.71 15416 20100216 IRM 21.85 22.41 21.69 22.4 11866 20100217 IRM 23.12 23.67 22.86 23.55 29934 20100218 IRM 23.59 23.89 23.5 23.84 12189 20100219 IRM 23.76 24.42 23.76 24.15 17870 20100222 IRM 24.28 24.44 23.69 23.87 16508 20100223 IRM 23.84 24.1 23.77 23.87 18686 20100224 IRM 23.98 24.45 23.94 24.3 23210 20100225 IRM 25.52 26.48 25.51 26.02 39638 20100226 IRM 26.12 26.24 25.81 25.88 20217 20100301 IRM 26.09 26.1 25.67 25.99 20794 20100302 IRM 26.12 26.15 25.71 25.83 12647 20100303 IRM 25.93 26.03 25.52 25.62 13923 20100304 IRM 25.69 25.7 25.36 25.64 9288 20100305 IRM 25.71 25.99 25.63 25.83 11017 20100308 IRM 25.93 26.01 25.76 25.84 6942 20100309 IRM 25.79 25.8252 25.49 25.65 11711 20100310 IRM 25.65 25.87 25.62 25.64 10709 20100311 IRM 25.53 25.8 25.42 25.77 6713 20100312 IRM 25.82 25.95 25.67 25.91 5875 20100315 IRM 26 26.12 25.82 26.05 8226 20100316 IRM 26.12 26.16 25.91 26.1 9241 20100317 IRM 26.29 26.41 26.07 26.39 8845 20100318 IRM 26.39 26.42 26.22 26.36 6167 20100319 IRM 26.41 26.55 25.9 26 11825 20100322 IRM 25.84 26.44 25.84 26.32 8405 20100323 IRM 26.55 27.28 26.44 27.28 17101 20100324 IRM 27.11 27.4 26.94 27.02 13172 20100325 IRM 27.27 27.52 27.07 27.1 13253 20100326 IRM 27.26 27.48 26.81 27.03 9221 20100329 IRM 27.07 27.74 27.07 27.74 13247 20100330 IRM 27.71 27.76 27.32 27.42 10949 20100331 IRM 27.23 27.45 27.08 27.4 11760 20100401 IRM 27.62 28 27.23 27.45 12633 20100405 IRM 27.53 27.55 27.21 27.3 11100 20100406 IRM 27.11 27.17 26.88 27.01 13262 20100407 IRM 26.9 26.99 26.62 26.72 10259 20100408 IRM 26.56 26.61 26.27 26.52 9966 20100409 IRM 26.58 26.72 26.45 26.51 9527 20100412 IRM 26.53 26.64 26.42 26.5 13564 20100413 IRM 26.42 26.61 26.21 26.5 11057 - ---- - -74.23 74.34 4038 20090825 DNB 74.91 75.07 73.85 74.26 4558 20090826 DNB 73.99 74.32 73.46 73.85 4202 20090827 DNB 73.63 74.1 72.67 73.37 3917 20090828 DNB 73.49 73.697 72.76 72.95 5499 20090831 DNB 72.84 73.18 72.62 73.04 3578 20090901 DNB 72.82 73.55 72.6 72.97 8135 20090902 DNB 72.65 73.19 72.2 72.94 6238 20090903 DNB 72.85 74.24 71.15 74.24 5219 20090904 DNB 73.93 74.89 73.93 74.55 4017 20090909 DNB 74.455 74.455 73.12 73.41 8212 20090910 DNB 73.4 73.78 72.89 73.39 7758 20090911 DNB 73.39 74.27 72.75 73.97 8094 20090914 DNB 73.93 74.9 73.74 74.67 5485 20090915 DNB 74.83 74.9 74.17 74.6 3541 20090916 DNB 74.46 74.82 74.02 74.76 3705 20090917 DNB 74.84 75.17 74.24 74.38 6057 20090918 DNB 74.86 74.86 74.02 74.26 4839 20090921 DNB 73.8 74.27 73.7 74.02 4500 20090922 DNB 73.83 74.41 73.78 74.32 3546 20090923 DNB 74.3 74.45 73.83 73.83 3920 20090924 DNB 74.19 74.37 73.76 74.03 4098 20090925 DNB 74 74.59 73.46 73.9 4841 20090928 DNB 73.87 74.69 73.69 74.42 3820 20090929 DNB 74.65 74.88 74.07 74.82 4810 20090930 DNB 74.47 75.49 74 75.32 5178 20091001 DNB 75 75 73.91 73.97 4501 20091002 DNB 73.45 74.09 73.18 73.26 3438 20091005 DNB 73.18 73.79 73.01 73.78 4376 20091006 DNB 73.98 74.86 73.59 74.58 2896 20091007 DNB 74.44 74.58 74.05 74.44 2455 20091008 DNB 74.87 75.76 74.64 75.3 2452 20091009 DNB 75.65 75.75 75.27 75.52 3041 20091012 DNB 75.49 75.7399 74.93 75.33 1733 20091013 DNB 74.93 75.01 74.46 74.78 1720 20091014 DNB 75.27 75.84 74.72 75.71 3934 20091015 DNB 75.69 75.99 75.2 75.95 3681 20091016 DNB 75.74 76.32 75.37 75.99 2760 20091019 DNB 76.22 76.945 75.92 76.82 1933 20091020 DNB 76.56 77.8 75.94 77.66 8088 20091021 DNB 77.55 77.99 77.25 77.35 4053 20091022 DNB 77.72 78.84 76.99 78.7 3960 20091023 DNB 78.56 79.1 78.34 78.75 4755 20091026 DNB 78.64 80.41 78.49 80.11 6557 20091027 DNB 80.35 81.26 80.24 80.43 6106 20091028 DNB 80.49 80.73 78.16 78.41 7853 20091105 DNB 77.53 79.35 77.53 79.31 3697 20091106 DNB 79.31 79.36 78.46 79.31 2901 20091109 DNB 79.42 81.36 79.22 81.34 3159 20091110 DNB 80.75 81.4 80.68 80.81 2955 20091111 DNB 81.13 81.43 80.46 80.81 2421 20091112 DNB 80.87 81.24 80.43 80.54 2127 20091113 DNB 80.82 81.77 80.33 80.8 1741 20091116 DNB 80.99 81.75 80.81 81.4 3338 20091117 DNB 81.4 81.68 81.2 81.4 2915 20091118 DNB 81.13 81.64 80.43 80.68 3196 20091119 DNB 80.61 80.88 79.44 79.99 2832 20091120 DNB 79.94 80 79.44 79.87 2348 20091123 DNB 80.1 81.03 80.1 80.5 1991 20091124 DNB 80.14 80.58 79.69 79.92 2168 20091125 DNB 79.92 80.21 79.7 79.96 2502 20091127 DNB 78.7 79.63 78.12 78.67 1313 20091130 DNB 78.66 78.81 77.89 78.59 4269 20091201 DNB 78.58 79.24 78.55 79 2511 20091202 DNB 79.07 79.64 78.75 79.05 3169 20091203 DNB 78.94 79.52 78.54 78.63 2554 20091204 DNB 79.61 79.99 79.24 79.93 3076 20091207 DNB 80.01 81.36 79.72 80.6 3518 20091208 DNB 80.16 81.41 79.9 80.38 3473 20091209 DNB 80.25 80.81 79.85 80.71 2871 20091210 DNB 81 82.54 80.92 82.29 4211 20091211 DNB 82.29 82.61 81.45 81.85 3201 20091214 DNB 82.28 82.53 81.91 82.45 2648 20091215 DNB 82.06 82.23 81.71 82.13 3432 20091216 DNB 82.27 82.55 81.97 82.25 3011 20091217 DNB 82.24 82.44 81.83 82.11 4628 20091218 DNB 82.3 82.3 81 82.02 6914 20091221 DNB 82.4 82.81 81.93 82.51 2941 20091222 DNB 82.81 82.81 82.37 82.79 2824 20091223 DNB 83 83.35 82.84 83.19 1186 20091224 DNB 83.22 83.68 83.22 83.68 490 20091228 DNB 83.75 84.03 83.68 83.9 1258 20091229 DNB 84.29 84.83 84.18 84.54 1608 20091230 DNB 84.43 84.95 84.35 84.64 1506 20091231 DNB 84.5 84.91 84.31 84.37 2208 20100104 DNB 84.61 84.61 82.95 83.37 4994 20100105 DNB 83.16 83.41 82.7 83.29 4134 20100106 DNB 82.93 83.54 82.73 83.34 3636 20100107 DNB 83.01 83.52 82.33 82.6 3567 20100108 DNB 82.34 82.47 81.42 81.74 3233 20100111 DNB 82.17 82.32 81.66 82.15 2615 20100112 DNB 81.73 82.42 81.57 82.07 1693 20100113 DNB 82.09 82.48 81.96 82.29 2250 20100114 DNB 82.08 82.5 81.78 82.43 2646 20100115 DNB 82.54 82.54 82.09 82.15 3390 20100119 DNB 82.35 82.65 82.05 82.6 1781 20100120 DNB 82.22 82.25 81.36 81.39 2858 20100121 - ---- - -15.1 15.16 14.86 14.87 192241 20100326 DELL 14.95 15 14.7 14.99 219025 20100329 DELL 15.1 15.2 14.92 14.96 120520 20100330 DELL 14.88 15.0696 14.832 14.97 124612 20100331 DELL 14.97 15.18 14.94 15.02 150498 20100401 DELL 15.04 15.19 14.92 15.05 139880 20100405 DELL 15.03 15.31 15 15.2 180900 20100406 DELL 15.1 15.63 15.1 15.57 295991 20100407 DELL 15.56 15.97 15.55 15.69 342419 20100408 DELL 15.52 15.78 15.425 15.76 223617 20100409 DELL 15.66 15.85 15.44 15.83 230560 20100412 DELL 15.78 15.99 15.77 15.93 221152 20100413 DELL 15.88 15.91 15.61 15.72 189759 20100414 DELL 15.97 16.685 15.96 16.56 576847 20100415 DELL 16.5 16.93 16.5 16.86 377477 20100416 DELL 16.93 17 16.63 16.76 420239 20100419 DELL 16.69 16.92 16.59 16.898 227750 20100420 DELL 16.93 17.04 16.6113 17.01 254324 20100421 DELL 17.1 17.2 16.95 17.17 241001 20100422 DELL 16.95 17.5 16.77 17.46 347483 20100423 DELL 17.37 17.52 17.24 17.5 220718 20100426 DELL 17.37 17.41 16.96 17.02 335800 20100427 DELL 16.87 16.98 16.5 16.53 307642 20100428 DELL 16.28 16.58 16.17 16.51 358713 20100429 DELL 16.55 16.7 16.44 16.65 197606 20100430 DELL 16.57 16.75 16.18 16.2 306242 20100503 DELL 16.29 16.46 16.21 16.38 235405 20100504 DELL 16.22 16.28 15.46 15.66 379276 20100505 DELL 15.56 15.98 15.48 15.77 271002 20100506 DELL 15.7 15.95 14.28 15.2 387187 20100507 DELL 15.1 15.4 14.62 15.01 444162 20100511 DELL 15.21 15.83 15.14 15.48 248219 20100512 DELL 15.56 15.8 15.51 15.72 229568 20100513 DELL 15.6 15.96 15.41 15.44 210809 20100514 DELL 15.33 15.39 14.93 15.15 218821 20100517 DELL 15.2 15.31 14.87 15.22 268941 20100518 DELL 15.33 15.45 14.9 15 213033 20100519 DELL 15.04 15.2 14.67 14.98 216003 20100520 DELL 14.63 14.65 14.27 14.32 455533 20100521 DELL 13.5 15 13.12 13.35 1015124 20100524 DELL 13.41 13.87 13.36 13.44 439819 20100526 DELL 13.44 13.63 13.24 13.25 346992 20100527 DELL 13.53 13.71 13.32 13.4 315485 20100528 DELL 13.47 13.53 13.19 13.33 217035 20100601 DELL 13.24 13.51 13.08 13.09 211150 20100602 DELL 13.13 13.28 12.9304 13.12 293408 20100603 DELL 13.24 13.96 13.23 13.7625 543109 20100604 DELL 13.34 13.52 13.15 13.24 300297 20100607 DELL 13.2 13.34 12.93 12.93 224392 20100608 DELL 12.94 13.02 12.56 12.68 388501 20100609 DELL 12.81 13.07 12.42 12.78 424612 20100610 DELL 13.01 13.1 12.87 13.07 225008 20100611 DELL 12.8 13.22 12.78 13.15 191039 20100614 DELL 13.3 13.44 13.04 13.09 205866 20100615 DELL 13.22 14.11 13.2 14 418732 20100616 DELL 13.87 14.06 13.77 13.99 226611 20100617 DELL 14.2 14.26 13.81 14.2 301265 20100618 DELL 14.27 14.28 13.94 14.04 205640 20100621 DELL 14.17 14.28 13.86 13.95 226079 20100622 DELL 14 14.2 13.76 13.8025 201894 20100623 DELL 13.82 13.96 13.61 13.82 214114 20100624 DELL 13.77 13.81 12.88 12.93 649121 20100625 DELL 13.07 13.12 12.65 12.9325 487941 20100628 DELL 12.99 13.12 12.87 12.95 303599 20100629 DELL 12.64 12.65 12.2 12.27 385016 20100630 DELL 12.23 12.46 12 12.06 273440 20100701 DELL 12.14 12.41 11.9 12.03 366715 20100702 DELL 12.05 12.14 11.9125 12.03 158142 20100707 DELL 11.85 12.48 11.83 12.4575 264398 20100708 DELL 12.57 12.79 12.47 12.78 261233 20100709 DELL 12.78 12.91 12.63 12.85 188557 20100712 DELL 12.75 13.03 12.7 12.84 150557 20100713 DELL 12.86 13.29 12.76 13.2 233600 20100714 DELL 13.4 13.86 13.4 13.52 288583 20100715 DELL 13.59 13.73 13.321 13.64 229069 20100716 DELL 13.61 13.74 13.04 13.065 232277 20100719 DELL 13.1 13.48 13.04 13.44 163825 20100720 DELL 13.15 13.38 13.01 13.36 208227 20100721 DELL 13.26 13.45 13.05 13.07 259295 20100722 DELL 13.31 13.52 13.18 13.4 211632 20100723 DELL 13.34 13.53 13.27 13.51 129470 20100726 DELL 13.48 13.76 13.45 13.74 102343 20100727 DELL 13.85 13.95 13.625 13.66 107014 20100728 DELL 13.6 13.73 13.42 13.5 86258 20100729 DELL 13.55 13.69 13.025 13.16 236332 20100730 DELL 13.04 13.37 13.01 13.24 141302 20100802 DELL 13.43 13.68 13.35 13.61 104059 20100803 DELL 13.55 13.6 13.34 13.42 91235 20100804 DELL 13.48 13.53 13.07 13.21 203854 20100805 DELL 13.08 13.22 12.87 13.13 253347 20100806 - ---- - -14.01 33411 20091203 MAS 14.05 14.31 13.97 14.18 48984 20091204 MAS 14.48 14.67 14.15 14.6 48573 20091207 MAS 14.51 14.64 13.84 13.91 45972 20091208 MAS 13.8 13.9 13.49 13.55 95818 20091209 MAS 13.62 13.65 13.19 13.47 25597 20091210 MAS 13.54 13.755 13.44 13.54 24507 20091211 MAS 13.795 13.795 13.35 13.55 24190 20091214 MAS 13.68 13.79 13.49 13.71 16624 20091215 MAS 13.61 13.77 13.46 13.56 21135 20091216 MAS 13.84 14.04 13.63 13.95 29149 20091217 MAS 13.81 13.9 13.66 13.72 21784 20091218 MAS 13.79 14.07 13.37 13.39 52225 20091221 MAS 13.51 13.87 13.51 13.75 30522 20091222 MAS 13.83 13.97 13.76 13.86 40708 20091223 MAS 13.94 14.15 13.85 14.13 27870 20091224 MAS 14.2 14.36 14.15 14.36 6984 20091228 MAS 14.48 14.48 13.9905 14.08 15528 20091229 MAS 14.13 14.16 13.77 14.01 22046 20091230 MAS 13.97 13.99 13.7 13.93 22137 20091231 MAS 13.89 14 13.79 13.81 24057 20100104 MAS 13.97 14.3 13.88 14.29 29705 20100105 MAS 14.2 14.43 14.12 14.42 28634 20100106 MAS 14.45 14.75 14.31 14.57 64244 20100107 MAS 14.56 15.57 14.51 15.48 84373 20100108 MAS 15.33 15.6 15 15.58 36123 20100111 MAS 15.71 15.75 15.36 15.54 28026 20100112 MAS 15.37 15.44 15.14 15.3 21662 20100113 MAS 15.34 15.35 14.85 15.1 33542 20100114 MAS 15.02 15.16 14.75 15.03 27769 20100115 MAS 15.32 15.34 14.86 15 55566 20100119 MAS 14.98 15.44 14.92 15.42 26992 20100120 MAS 15.02 15.12 14.73 14.95 30602 20100121 MAS 15.1 15.1 14.39 14.49 40096 20100122 MAS 14.41 14.74 13.9 13.91 33360 20100125 MAS 14.13 14.27 13.74 13.78 33919 20100126 MAS 13.69 14.08 13.62 13.78 44976 20100127 MAS 13.63 13.68 13.21 13.58 63034 20100128 MAS 13.68 13.99 13.33 13.6 48385 20100129 MAS 13.7 14.06 13.48 13.56 65539 20100201 MAS 13.69 14 13.56 13.99 37257 20100202 MAS 13.96 14.8 13.94 14.78 53058 20100203 MAS 14.66 15 14.66 14.85 46821 20100204 MAS 14.64 14.65 14.26 14.5 67753 20100205 MAS 14.41 14.49 13.6 14.14 56167 20100208 MAS 14.09 14.23 13.85 14.05 32373 20100209 MAS 14.34 14.62 14.07 14.45 46548 20100210 MAS 14.46 14.5925 14.07 14.5 31375 20100211 MAS 13.84 14.08 12.78 13.77 128226 20100212 MAS 13.49 13.81 13.35 13.81 71434 20100216 MAS 13.9 14.06 13.71 14 42476 20100217 MAS 14.12 14.12 13.75 13.95 45162 20100218 MAS 13.95 14.04 13.761 13.83 37194 20100219 MAS 13.77 13.81 13.56 13.6 62581 20100222 MAS 13.69 13.95 13.6 13.62 36899 20100223 MAS 13.68 13.72 13.045 13.25 46675 20100224 MAS 13.3 13.36 12.91 13.31 33789 20100225 MAS 13 13.19 12.7601 13.16 43800 20100226 MAS 13.22 13.45 13.01 13.37 48175 20100301 MAS 13.47 14.005 13.47 13.97 45516 20100302 MAS 14.11 14.13 13.9 14.02 27815 20100303 MAS 14.13 14.44 13.99 14.17 32560 20100304 MAS 14.18 14.35 14.01 14.14 19159 20100305 MAS 14.28 14.425 14.25 14.39 19273 20100308 MAS 14.43 14.66 14.4 14.66 21639 20100309 MAS 14.59 14.75 14.51 14.68 24474 20100310 MAS 14.64 14.96 14.62 14.86 35630 20100311 MAS 14.77 15.17 14.65 15.12 36722 20100312 MAS 15.2 15.32 14.96 15.17 30944 20100315 MAS 15.16 15.23 14.97 15.15 28161 20100316 MAS 15.2 15.35 15.07 15.31 24491 20100317 MAS 15.34 15.74 15.3 15.53 32709 20100318 MAS 15.47 15.75 15.42 15.51 23211 20100319 MAS 15.55 15.75 15 15 58149 20100322 MAS 14.85 15.26 14.82 15.23 28325 20100323 MAS 15.23 15.52 15.04 15.48 41121 20100324 MAS 15.5 15.66 15.13 15.17 40392 20100325 MAS 15.37 15.48 15.11 15.13 34641 20100326 MAS 15.23 15.4 15.045 15.19 27866 20100329 MAS 15.28 15.45 15.13 15.32 26264 20100330 MAS 15.32 15.59 15.3 15.4 17038 20100331 MAS 15.29 15.66 15.0801 15.52 53990 20100401 MAS 15.68 15.95 15.63 15.81 43077 20100405 MAS 15.91 16.22 15.71 16.15 31736 20100406 MAS 16.07 16.33 15.92 16.28 35030 20100407 MAS 16.16 16.22 15.72 15.85 43063 20100408 MAS 15.8 15.96 15.56 15.89 39639 20100409 MAS 15.9 16.12 15.81 16.1 29068 20100412 MAS 16.18 16.18 15.91 16.11 32088 20100413 MAS 16.03 16.22 16.02 16.14 24914 20100414 MAS 16.23 16.91 16.18 16.88 42258 20100415 MAS 16.81 17.4 16.68 17 62629 20100416 MAS 17.44 17.72 16.82 16.96 72317 20100419 MAS 16.86 17.25 16.7 17.24 57164 20100420 MAS 17.38 17.67 17.26 17.49 - ---- - -16.43 16.54 15.85 16.5 167198 20100208 WU 16.53 16.55 16.14 16.16 147857 20100209 WU 16.35 16.51 15.93 16.14 194611 20100210 WU 16.14 16.6 16.01 16.44 157284 20100211 WU 16.3 16.41 16.1 16.16 157815 20100212 WU 16.14 16.32 15.96 16.12 103030 20100216 WU 16.36 16.6 16.12 16.5 95556 20100217 WU 16.5 16.71 16.4 16.4 46418 20100218 WU 16.4 16.52 16.39 16.46 46256 20100219 WU 16.39 16.46 16.27 16.35 69631 20100222 WU 16.38 16.4 16.12 16.18 87056 20100223 WU 16.29 16.315 16.04 16.04 75706 20100224 WU 16.13 16.17 15.96 16 79066 20100225 WU 15.85 16.04 15.71 15.96 86718 20100226 WU 16.01 16.02 15.72 15.78 73908 20100301 WU 15.88 16.07 15.76 16 77322 20100302 WU 16.28 16.29 15.81 15.84 89304 20100303 WU 15.91 15.99 15.71 15.71 71497 20100304 WU 15.77 16.1 15.68 16.02 99277 20100305 WU 16.16 16.34 16.02 16.31 68465 20100308 WU 16.34 16.37 16.18 16.22 57369 20100309 WU 16.18 16.37 16.04 16.33 90195 20100310 WU 16.35 16.54 16.15 16.51 96406 20100311 WU 16.48 16.83 16.395 16.77 78274 20100312 WU 16.86 16.92 16.69 16.91 55757 20100315 WU 16.86 16.89 16.59 16.71 87102 20100316 WU 16.44 16.81 16.17 16.24 156679 20100317 WU 16.3 16.85 16.25 16.8 100281 20100318 WU 16.84 16.865 16.65 16.8 64541 20100319 WU 16.87 16.93 16.57 16.66 79759 20100322 WU 16.58 16.96 16.58 16.91 61887 20100323 WU 16.92 17.17 16.9 17.06 68676 20100324 WU 17.02 17.04 16.8 16.88 58659 20100325 WU 17.04 17.23 16.94 16.97 127809 20100326 WU 17.08 17.08 16.92 17.05 50758 20100329 WU 17.16 17.26 17.1 17.19 37813 20100330 WU 17.25 17.27 16.91 17 52737 20100331 WU 16.98 17.09 16.9 16.96 74017 20100401 WU 17.1 17.4 16.94 17.06 69689 20100405 WU 17.13 17.46 17.08 17.37 66806 20100406 WU 17.35 17.65 17.35 17.5 75675 20100407 WU 17.41 17.58 17.18 17.24 66216 20100408 WU 17.21 17.51 17.12 17.41 62757 20100409 WU 17.4 17.55 17.34 17.49 53839 20100412 WU 17.51 17.76 17.43 17.47 52738 20100413 WU 17.37 17.54 17.3 17.49 45569 20100414 WU 17.58 17.73 17.44 17.64 59069 20100415 WU 17.61 17.73 17.5 17.53 55816 20100416 WU 17.48 17.5825 17.15 17.24 58437 20100419 WU 17.17 17.43 17.17 17.3 69093 20100420 WU 17.4 17.46 17.265 17.4 52640 20100421 WU 17.37 17.46 17.3 17.44 60879 20100422 WU 17.25 17.5 17.23 17.45 82361 20100423 WU 17.42 17.78 17.37 17.78 51030 20100426 WU 17.87 18.23 17.81 17.91 148850 20100427 WU 18.85 19.57 18.85 19 328364 20100428 WU 19.02 19.09 18.36 18.62 150514 20100429 WU 18.7 18.94 18.45 18.68 85543 20100430 WU 18.67 18.79 18.21 18.25 116641 20100503 WU 18.4 18.46 18.18 18.22 76098 20100504 WU 18.03 18.03 17.61 17.78 111053 20100505 WU 17.6 17.89 17.46 17.58 54561 20100506 WU 17.46 17.65 16.3 17.22 150122 20100507 WU 17.15 17.26 16.35 16.55 153206 20100510 WU 17.24 17.38 17.09 17.24 113358 20100511 WU 17.16 17.16 16.6 16.79 91761 20100512 WU 16.84 17.13 16.75 17.06 75156 20100513 WU 16.98 17.26 16.98 17.01 84978 20100514 WU 16.94 17.01 16.5295 16.64 111585 20100517 WU 16.67 16.92 16.35 16.62 90215 20100518 WU 16.79 16.9 16.15 16.19 96706 20100519 WU 16.26 16.37 16.02 16.05 142447 20100520 WU 15.74 15.95 15.38 15.47 111394 20100521 WU 15.2 15.92 15.2 15.9 112103 20100524 WU 15.8 15.89 15.58 15.58 57744 20100525 WU 15.24 15.7 15.1505 15.69 92385 20100526 WU 15.69 16.07 15.6 15.66 106373 20100527 WU 15.91 16.28 15.82 16.26 73018 20100528 WU 16.25 16.32 15.9 15.96 54417 20100601 WU 15.78 16.1 15.68 15.69 84075 20100602 WU 15.8 15.86 15.66 15.76 88875 20100603 WU 15.82 16.16 15.79 16.15 68671 20100604 WU 15.76 16 15.59 15.63 100250 20100607 WU 15.73 15.82 15.27 15.31 92919 20100608 WU 15.39 15.44 15.1 15.44 88904 20100609 WU 15.5 15.79 15.35 15.51 66814 20100610 WU 15.72 16.08 15.72 16.07 65891 20100611 WU 15.87 16.1 15.87 16.09 52091 20100614 WU 16.24 16.31 15.91 15.93 52444 20100615 WU 16.1 16.38 16.07 16.38 88547 20100616 WU 16.26 16.35 16.1 16.23 48425 20100617 WU 16.31 16.34 16.11 16.27 30563 20100618 WU 16.23 16.35 16.15 16.2 47364 20100621 WU 16.4 16.5 15.92 16 44432 20100622 WU 16 16.08 15.76 15.78 47891 20100623 WU 15.71 15.89 15.505 15.8 45359 20100624 WU 15.73 - ---- - -AGN 60.69 60.83 60.13 60.36 12153 20091214 AGN 60.82 61.95 60.66 61.71 18194 20091215 AGN 61.65 61.83 61.055 61.74 12228 20091216 AGN 61.76 61.89 60.85 60.92 17258 20091217 AGN 60.47 61.31 59.835 60.34 10971 20091218 AGN 60.41 60.835 59.7 60.64 20460 20091221 AGN 61.18 61.99 61.09 61.5 12170 20091222 AGN 61.79 62.5 60.78 62.26 12789 20091223 AGN 62.1 62.74 62.1 62.6 10671 20091224 AGN 62.83 62.97 62.42 62.64 6154 20091228 AGN 62.58 63.5 62.58 63.45 12143 20091229 AGN 63.43 64.08 63.28 63.61 13955 20091230 AGN 62.88 63.49 62.1 63.49 12923 20091231 AGN 63.5 63.68 63 63.01 9412 20100104 AGN 63.56 63.74 62.6 63.32 17448 20100105 AGN 63.12 63.67 62.62 62.85 12516 20100106 AGN 62.67 63.11 62.24 62.46 21291 20100107 AGN 62.23 62.4 61.02 61.12 25853 20100108 AGN 60.85 61.045 60.045 60.47 26506 20100111 AGN 60.56 60.67 60.05 60.64 18336 20100112 AGN 60.34 60.48 59.86 60.12 14962 20100113 AGN 60.34 60.49 58.92 59.87 25525 20100114 AGN 59.85 60.43 59.52 60.19 14575 20100115 AGN 60.37 60.85 59.95 60.04 24970 20100119 AGN 60.17 61.79 59.9 61.74 25642 20100120 AGN 61.46 61.98 60.51 61.2 20432 20100121 AGN 61.31 61.38 59.69 59.75 19502 20100122 AGN 59.49 60.06 58.68 58.71 20101 20100125 AGN 58.93 59.15 58.17 58.46 16751 20100126 AGN 58.27 58.5899 57.75 58.14 12029 20100127 AGN 57.97 59.0975 57.65 58.99 16308 20100128 AGN 59.17 59.2 57.66 57.66 18697 20100129 AGN 57.89 58.01 57.01 57.5 21060 20100201 AGN 57.69 58.07 57.38 58.02 18886 20100202 AGN 58.13 58.47 56.08 56.96 50877 20100203 AGN 56.64 57.2325 56.07 56.77 33547 20100204 AGN 55.35 59.36 55.25 57.39 71432 20100205 AGN 57.08 58.36 56.99 58.03 45467 20100208 AGN 57.91 58.66 57.43 58.17 25055 20100209 AGN 58.59 59.35 58.27 58.75 23361 20100210 AGN 58.8 58.89 57.78 58.48 17583 20100211 AGN 58.41 59.86 58.12 59.67 19067 20100212 AGN 59.23 59.47 58.46 59.45 19757 20100216 AGN 59.82 59.95 59.28 59.85 12863 20100217 AGN 60.1 60.1 59.6 59.74 11455 20100218 AGN 59.46 59.65 59.06 59.62 10862 20100219 AGN 59.46 59.74 58.98 59.53 11395 20100222 AGN 59.52 59.52 58.61 59.13 13294 20100223 AGN 58.96 59.2 58.09 58.23 13249 20100224 AGN 58.47 58.865 58.25 58.82 9480 20100225 AGN 58.6 58.73 57.75 58.72 12460 20100226 AGN 58.75 58.89 58.3 58.43 13373 20100301 AGN 58.59 60 58.4 59.61 17878 20100302 AGN 59.955 60.38 59.73 60.13 17132 20100303 AGN 60.37 60.6 59.58 59.67 8576 20100304 AGN 59.79 60.21 59.67 60.1 10418 20100305 AGN 61.04 62.15 60.94 62.1 20656 20100308 AGN 62.05 62.05 61.33 61.54 14248 20100309 AGN 61.28 61.61 60.99 61.35 9945 20100310 AGN 62.6 62.78 61.9 62.11 23722 20100311 AGN 61.88 62.11 61.15 62.11 15120 20100312 AGN 62.12 62.35 61.01 62.31 15655 20100315 AGN 62.15 62.85 61.94 62.84 19431 20100316 AGN 62.93 63.05 62.4 62.97 10455 20100317 AGN 62.91 63.82 62.87 63.81 15703 20100318 AGN 63.73 63.745 62.88 63.69 11696 20100319 AGN 63.84 64.86 63.57 64 24149 20100322 AGN 63.88 64.69 63.76 64.36 10681 20100323 AGN 64.42 64.51 64 64.39 11744 20100324 AGN 64.06 64.35 63.89 64.1 14427 20100325 AGN 64.51 65.05 64 64.06 23204 20100326 AGN 64.15 64.33 64 64.12 13570 20100329 AGN 64.24 64.79 64.14 64.42 15393 20100330 AGN 64.32 64.95 64.21 64.9 17351 20100331 AGN 64.62 65.79 64.335 65.32 25353 20100401 AGN 65.55 65.87 65.02 65.25 15062 20100405 AGN 65.34 65.53 65.08 65.17 14181 20100406 AGN 64.92 65.14 64.42 64.48 24444 20100407 AGN 64.08 64.11 62.82 63.15 31880 20100408 AGN 63.22 63.69 63 63.55 23085 20100409 AGN 63.61 63.74 63.11 63.33 16826 20100412 AGN 63.45 63.76 63.08 63.17 12142 20100413 AGN 63.19 63.22 62.58 62.73 19331 20100414 AGN 62.63 62.91 62.13 62.53 20126 20100415 AGN 62.34 62.68 62.05 62.36 19863 20100416 AGN 62.19 62.54 61.41 61.71 23861 20100419 AGN 62.61 63.58 62.43 63.2 23429 20100420 AGN 63.43 64.65 63.1 64.44 26019 20100421 AGN 64.51 64.51 62.28 62.55 24073 20100422 AGN 62.44 62.5 61.3675 62 22313 20100423 AGN 61.84 62.45 61.43 62.4 15348 20100426 AGN 62.44 62.85 61.79 61.8 14490 20100427 AGN 61.49 62.48 60.36 60.41 21184 20100428 AGN 60.71 61.42 60.71 60.95 15815 20100429 AGN - ---- - -25.04 121507 20100604 TXN 24.66 24.95 24.07 24.1775 145425 20100607 TXN 24.32 24.56 23.605 23.67 168834 20100608 TXN 23.99 24 23.09 23.88 191134 20100609 TXN 24.3 24.54 23.64 23.74 198828 20100610 TXN 24.2 24.57 24.04 24.53 173087 20100611 TXN 24.27 24.59 24.15 24.45 139429 20100614 TXN 24.74 24.89 24.505 24.57 146041 20100615 TXN 24.75 25.76 24.53 25.7 177404 20100616 TXN 25.33 25.6 25.1 25.42 193052 20100617 TXN 25.69 25.69 25.21 25.53 100562 20100618 TXN 25.51 25.69 25.27 25.45 120382 20100621 TXN 25.76 25.85 25.11 25.25 111238 20100622 TXN 25.34 25.58 24.69 24.75 119284 20100623 TXN 24.88 25.1 24.47 24.78 114484 20100624 TXN 24.6 24.75 24.17 24.28 147246 20100625 TXN 24.22 24.43 23.86 24.04 261271 20100628 TXN 24.16 24.5029 24.02 24.36 116704 20100629 TXN 24.05 24.09 23.68 23.89 194089 20100630 TXN 24.01 24.07 23.155 23.28 174784 20100701 TXN 23.21 23.47 22.65 23.17 164401 20100702 TXN 23.3 23.39 22.71 23.11 113369 20100706 TXN 23.37 23.54 22.935 23.12 134752 20100707 TXN 23.2 24.27 23.15 24.25 168523 20100708 TXN 24.42 24.47 23.86 24.22 106708 20100709 TXN 24.38 24.51 24.17 24.48 76985 20100712 TXN 24.36 24.8 24.36 24.75 98224 20100713 TXN 25.08 25.54 24.95 25.39 152120 20100714 TXN 25.58 25.8 24.96 25.09 175930 20100715 TXN 25.07 25.45 24.75 25.4 141226 20100716 TXN 25.2 25.43 24.73 24.77 120036 20100719 TXN 24.87 25.58 24.87 25.55 155059 20100720 TXN 24.16 24.89 24.01 24.77 309339 20100721 TXN 24.77 24.92 24.4 24.5 152498 20100722 TXN 24.67 25.42 24.65 25.29 156360 20100723 TXN 25.25 25.46 25 25.38 125157 20100726 TXN 25.28 25.66 25.09 25.66 95690 20100727 TXN 25.79 25.92 25.47 25.58 131525 20100728 TXN 25.42 25.62 25.1 25.22 119580 20100729 TXN 25.35 25.4 24.64 24.88 121899 20100730 TXN 24.59 24.88 24.25 24.69 131517 20100802 TXN 24.65 25.23 24.41 25.11 91193 20100803 TXN 25.07 25.1 24.7 24.81 92040 20100804 TXN 24.82 25.25 24.62 25.18 106723 20100805 TXN 25.07 25.53 24.9 25.4 134111 20100806 TXN 25.2 25.6 25.06 25.46 120034 20100809 TXN 25.55 25.85 25.35 25.7 89194 20100810 TXN 25.38 25.54 24.97 25.35 154172 20100811 TXN 25.01 25.14 24.86 24.97 127472 20100812 TXN 24.3 24.97 24.22 24.41 181362 20100813 TXN 24.29 24.69 24.24 24.28 98361 20100816 TXN 24.18 24.59 24.03 24.53 101808 20100817 TXN 24.8 24.87 24.65 24.7 99308 20100819 TXN 24.85 25.05 24.45 24.53 94494 20100820 TXN 24.44 24.87 24.44 24.7 125890 20090821 TXT 14.31 14.82 14.23 14.58 45236 20090824 TXT 14.71 15.07 14.52 14.75 56599 20090825 TXT 14.91 15 14.65 14.8 58474 20090826 TXT 14.73 15.71 14.68 15.64 117460 20090827 TXT 15.64 15.78 15.15 15.52 65617 20090828 TXT 15.74 15.8 15.33 15.67 63314 20090831 TXT 15.48 15.52 15.19 15.36 45652 20090901 TXT 16.11 16.69 15.5 15.5 124781 20090902 TXT 16.4 17.76 15.92 17.39 238593 20090903 TXT 17.68 17.72 16.34 16.86 132742 20090904 TXT 16.81 17.24 16.5 17.07 58235 20090909 TXT 18.14 18.789 18 18.41 107293 20090910 TXT 18.53 19.09 18.35 19.02 79966 20090911 TXT 19.55 20 18.93 19.02 128897 20090914 TXT 18.84 19.33 18.65 19.27 80881 20090915 TXT 19.41 20.58 19.135 20.55 146774 20090916 TXT 20.85 20.99 19.91 20.15 107409 20090917 TXT 20.17 20.84 19.18 19.4 107824 20090918 TXT 19.42 19.68 19.15 19.44 73975 20090921 TXT 19.07 19.4 18.58 19.25 61067 20090922 TXT 19.51 19.6517 19.1 19.37 61233 20090923 TXT 19.28 19.37 18.6 19.2 73556 20090924 TXT 19.25 19.34 18.11 18.34 67822 20090925 TXT 17.51 18.16 17.3 17.88 101209 20090928 TXT 18.3 18.89 18.06 18.59 46842 20090929 TXT 18.68 18.89 18.1 18.71 54389 20090930 TXT 18.76 19.25 18.4 18.98 83710 20091001 TXT 18.81 18.98 18.12 18.15 72058 20091002 TXT 17.5 17.95 17.39 17.51 73017 20091005 TXT 18.08 18.46 17.77 18.45 40629 20091006 TXT 18.7 19.31 18.5 18.72 52483 20091007 TXT 18.69 18.87 18.44 18.7 25149 20091008 TXT 18.9 19.49 18.9 19.38 33587 20091009 TXT 19.28 19.57 19 19.49 30221 20091012 TXT 19.6 20 19.48 19.6 27789 20091013 TXT 19.51 19.59 19.1 19.15 37679 20091014 TXT 19.54 20.15 19.39 20.07 52575 20091015 TXT 20.03 20.34 19.61 20.34 44449 20091016 TXT 20.09 20.39 19.55 19.92 - ---- - -NOC 59.72 59.95 59.4 59.94 19530 20100218 NOC 59.72 61.51 59.66 61.51 32925 20100219 NOC 61.09 61.79 60.94 61.21 27664 20100222 NOC 61.22 62.05 61.18 61.67 17273 20100223 NOC 61.48 62.23 61.21 61.24 17613 20100224 NOC 61.47 62 61.18 61.69 18620 20100225 NOC 61.17 61.19 60.16 61.12 27651 20100226 NOC 61.14 61.42 60.36 61.26 34120 20100301 NOC 61.34 63.23 61.15 63.01 24483 20100302 NOC 62.96 63.6675 62.8 62.91 21228 20100303 NOC 62.94 63.03 61.95 62.32 24929 20100304 NOC 62.29 63.3 62.08 63.08 34225 20100305 NOC 63.42 64.36 63.38 64.22 13783 20100308 NOC 64.16 64.44 63.75 64.16 12725 20100309 NOC 63.96 64.52 63.69 64 18313 20100310 NOC 63.86 64.71 63.78 64.55 14181 20100311 NOC 64.55 64.8 63.87 64.75 13024 20100312 NOC 64.73 64.97 63.85 64 18720 20100315 NOC 63.98 64.37 63.8 64.31 17393 20100316 NOC 64.43 64.89 64.29 64.63 15572 20100317 NOC 64.88 65.34 64.56 64.9 14871 20100318 NOC 65.03 65.1 64.73 65.05 14973 20100319 NOC 65.19 65.61 64.91 65.54 43421 20100322 NOC 65.26 65.37 64.8 64.94 21508 20100323 NOC 65.05 65.325 64.83 65.19 21434 20100324 NOC 65.14 65.35 64.73 64.94 16909 20100325 NOC 65.42 65.6 64.94 64.98 15688 20100326 NOC 65.02 65.68 65.02 65.53 17588 20100329 NOC 65.72 66.056 65.52 65.78 20192 20100330 NOC 65.95 65.95 65.35 65.72 14266 20100331 NOC 65.39 65.88 65.19 65.57 19694 20100401 NOC 66.05 66.61 65.79 66.25 15818 20100405 NOC 66.45 66.69 66.19 66.42 13809 20100406 NOC 66.2 66.2 65.54 65.73 14334 20100407 NOC 65.4 65.9 65.14 65.22 20072 20100408 NOC 65.18 65.265 64.64 65.1 16578 20100409 NOC 65.08 66.19 65.07 66.15 18137 20100412 NOC 66.15 66.63 66.095 66.22 13888 20100413 NOC 66.05 66.79 65.6 66.64 17772 20100414 NOC 66.84 66.86 65.84 66.85 13776 20100415 NOC 66.64 67 66.34 66.82 13210 20100416 NOC 66.72 66.8291 65.43 65.97 17347 20100419 NOC 65.68 66.5 65.6 66.42 13482 20100420 NOC 66.62 67.61 66.47 67.43 16203 20100421 NOC 67.17 68.39 66.94 68.37 15057 20100422 NOC 67.96 69.07 67.79 68.99 18474 20100423 NOC 69.04 69.04 68.15 68.99 11429 20100426 NOC 69.04 69.63 68.85 68.93 16073 20100427 NOC 68.77 68.77 67.1 67.18 19962 20100428 NOC 69.47 69.8 67.75 68.67 33330 20100429 NOC 68.98 69.75 68.4 69.38 17920 20100430 NOC 69.31 69.7199 67.77 67.83 20244 20100503 NOC 68.22 69.38 68.11 69.24 13654 20100504 NOC 68.48 68.48 66.22 66.66 21487 20100505 NOC 66.2 67.11 66.2 66.88 15673 20100506 NOC 66.6 66.72 60.34 64.57 25525 20100507 NOC 64.34 64.68 62.34 62.84 27969 20100510 NOC 64.85 65.43 63.73 64.8775 28427 20100511 NOC 63.72 65.7 63.42 64.89 18880 20100512 NOC 64.89 65.88 64.83 65.75 10892 20100513 NOC 65.49 65.94 64.79 64.98 9073 20100514 NOC 64.42 64.79 62.79 63.29 14532 20100517 NOC 63.21 64.09 62.38 63.67 14900 20100518 NOC 64.18 64.58 62.84 62.85 17643 20100519 NOC 62.49 62.97 61.38 62.27 19684 20100520 NOC 61.12 61.47 59.67 60.02 25378 20100521 NOC 59.03 61.18 58.56 61.13 30336 20100524 NOC 60.81 61.48 60.18 60.25 21205 20100525 NOC 58.89 60.99 58.7 60.8 40465 20100526 NOC 61.31 61.68 60.09 60.18 34276 20100527 NOC 60.7 61.06 60.21 61.03 22411 20100528 NOC 61.16 61.37 60.27 60.49 21035 20100601 NOC 60.17 61.11 59.5 59.54 20309 20100602 NOC 59.72 60.87 59.66 60.82 26540 20100603 NOC 61.05 61.97 60.67 60.93 18542 20100604 NOC 59.65 59.91 58.04 58.24 18948 20100607 NOC 58.36 58.37 57.06 57.09 23035 20100608 NOC 56.73 57.46 56.33 57.38 20723 20100609 NOC 57.63 58.69 57.32 57.56 18782 20100610 NOC 58.41 59.17 58.24 59.05 15413 20100611 NOC 58.43 59.74 58.12 59.69 16210 20100614 NOC 60.17 60.71 59.62 59.74 18864 20100615 NOC 59.92 60.62 59.74 60.5 26963 20100616 NOC 60.41 61.27 60.33 61.08 22161 20100617 NOC 61.73 61.88 60.81 61.5 17581 20100618 NOC 61.56 62.16 61.44 62.08 20192 20100621 NOC 62.95 63.06 61 61.24 19835 20100622 NOC 61.1 61.67 60.12 60.25 18620 20100623 NOC 60.11 60.52 59.45 59.93 16025 20100624 NOC 59.73 60.06 58.7 58.88 20446 20100625 NOC 59.02 59.06 58.05 58.6 25155 20100628 NOC 58.81 59.39 58.26 58.42 21787 20100629 NOC 57.6 57.85 55.21 55.52 35725 20100630 NOC 55.19 55.78 54.37 54.44 37896 - ---- - -37.2 59470 20091217 JEC 37.01 37.23 36.75 37.09 23188 20091218 JEC 37.41 38.04 37.26 37.74 29301 20091221 JEC 38.18 38.18 37.42 37.74 17215 20091222 JEC 37.67 38.43 37.63 38.14 16013 20091223 JEC 38.19 38.52 37.91 38.48 18153 20091224 JEC 38.49 38.99 38.48 38.68 5965 20091228 JEC 38.65 38.97 38.36 38.49 10961 20091229 JEC 38.64 38.76 38.41 38.49 9651 20091230 JEC 38.47 38.47 37.75 37.92 10939 20091231 JEC 37.95 38.24 37.57 37.61 10460 20100104 JEC 38.1 38.46 37.93 38.45 17284 20100105 JEC 38.45 39 38.23 38.96 15102 20100106 JEC 38.85 40.3 38.8 40.25 25796 20100107 JEC 40.46 41.94 40.4355 41.84 34675 20100108 JEC 41.52 42.0798 41.42 41.74 19176 20100111 JEC 41.97 42.2198 41.26 41.31 15104 20100112 JEC 40.91 41.39 40.33 41.19 15583 20100113 JEC 41.15 41.42 40.02 40.93 15923 20100114 JEC 40.92 41.36 40.675 41.09 10566 20100115 JEC 40.9 41.31 40.04 40.27 15575 20100119 JEC 40.32 40.59 40.04 40.59 14880 20100120 JEC 40.2 40.25 39.6 40.14 20658 20100121 JEC 40.08 40.3 39.37 39.9 31641 20100122 JEC 39.71 40.4422 39.1805 39.66 35113 20100125 JEC 39.88 40.28 39.55 39.95 25945 20100126 JEC 41.09 41.09 38.89 38.94 23597 20100127 JEC 39.54 39.9 38.7602 39.42 24510 20100128 JEC 39.69 39.74 37.88 38.08 22873 20100129 JEC 38.19 39.19 37.68 37.79 17930 20100201 JEC 38.05 38.38 37.92 38.31 18520 20100202 JEC 37.22 37.9 36.8 37.35 32224 20100203 JEC 37.86 38.45 37.36 37.57 18715 20100204 JEC 37.17 37.38 36.17 36.18 17500 20100205 JEC 36.22 36.3 35.02 35.93 23398 20100208 JEC 36.01 36.85 35.39 36.23 19740 20100209 JEC 36.74 37.11 36.1801 36.7 17837 20100210 JEC 36.72 36.84 36.0708 36.29 13260 20100211 JEC 36.25 36.86 36.06 36.8 15059 20100212 JEC 36.34 36.57 35.87 36.5 13144 20100216 JEC 37 38.36 36.85 38.27 22953 20100217 JEC 38.59 38.81 38.19 38.74 13430 20100218 JEC 38.58 39.4399 38.58 39.36 9807 20100219 JEC 39.11 39.5 38.86 39.32 13837 20100222 JEC 39.51 39.68 39.1105 39.32 8895 20100223 JEC 39.13 39.26 38.55 38.87 17646 20100224 JEC 38.81 39.71 38.81 39.47 17087 20100225 JEC 38.86 39.45 38.44 39.4 13173 20100226 JEC 39.24 39.48 38.71 38.8 18613 20100301 JEC 38.91 39.71 38.91 39.43 11884 20100302 JEC 39.64 39.96 39.5299 39.87 14743 20100303 JEC 39.95 40.8 39.88 40.31 16523 20100304 JEC 40.35 40.56 40.03 40.19 9516 20100305 JEC 40.38 41.44 40.38 41.44 18354 20100308 JEC 41.93 42.97 41.85 42.01 19697 20100309 JEC 42.87 43.5 42.39 42.85 22693 20100310 JEC 42.87 43.26 42.73 42.9 13656 20100311 JEC 42.72 43.365 42.38 43.25 11703 20100312 JEC 43.45 43.69 43.1301 43.55 8888 20100315 JEC 43.55 43.64 42.73 43.43 9970 20100316 JEC 43.49 44 43.26 43.97 11044 20100317 JEC 44.15 45.04 44.15 44.43 18851 20100318 JEC 44.31 44.43 43.41 43.85 11846 20100319 JEC 43.88 44.2099 42.98 43.1 16867 20100322 JEC 42.94 43.605 42.73 43.4 8542 20100323 JEC 43.51 44.37 43.35 44.24 11121 20100324 JEC 44.9 46.13 44.9 45.97 34284 20100325 JEC 46.11 46.3 45.3 45.41 15948 20100326 JEC 45.49 45.5999 44.6299 44.87 12568 20100329 JEC 45.05 45.74 44.94 45.65 11408 20100330 JEC 45.61 45.87 45.14 45.41 12312 20100331 JEC 45.2 45.51 45 45.19 10306 20100401 JEC 45.52 46.07 45.429 45.77 10521 20100405 JEC 45.97 46.4 45.78 46.17 11687 20100406 JEC 45.88 46.26 45.275 45.41 26147 20100407 JEC 45.155 45.69 43.87 44.37 27867 20100408 JEC 44.09 44.43 43.83 44.28 18456 20100409 JEC 44.36 48.2799 44.18 47.61 97657 20100412 JEC 47.36 47.36 46.44 46.74 21660 20100413 JEC 46.71 47.48 46.62 47.35 20092 20100414 JEC 47.58 47.94 47.12 47.86 12157 20100415 JEC 47.7 48.24 47.5 47.91 9562 20100416 JEC 47.77 47.8 46.25 46.9 17834 20100419 JEC 46.7 47.19 46.11 46.77 13834 20100420 JEC 47.22 47.85 46.76 47.57 10649 20100421 JEC 47.66 48.34 47.4 48.13 11225 20100422 JEC 47.71 48.9 46.92 48.85 12029 20100423 JEC 48.9 49.44 48.49 49.21 12761 20100426 JEC 49.605 49.7 48.2 48.67 18374 20100427 JEC 46.9 50.68 46.08 47.46 38415 20100428 JEC 47.86 49.16 47.86 48.38 17451 20100429 JEC 49.05 50.02 48.85 49.97 15576 20100430 JEC 50.12 50.2 48.12 48.22 18082 20100503 JEC 48.66 49.29 48.16 49.13 16006 20100504 JEC - ---- - -SEE 19.8 20.1 19.75 20.04 7041 20091014 SEE 20.27 20.54 20.14 20.4 7739 20091015 SEE 20.24 20.5 20.15 20.48 7890 20091016 SEE 20.4 20.45 19.98 20.22 6534 20091019 SEE 20.21 20.59 20.14 20.55 6137 20091020 SEE 21.18 21.35 20.755 20.94 12219 20091021 SEE 20.94 21.29 20.45 20.49 11210 20091022 SEE 20.54 20.71 20.3 20.68 9808 20091023 SEE 20.72 20.72 20.02 20.24 9708 20091026 SEE 20.23 20.58 19.7 19.9 8356 20091027 SEE 20.01 20.38 19.8 19.86 13998 20091028 SEE 21.25 21.38 19.33 19.6 32659 20091105 SEE 20.35 20.98 20.35 20.95 18801 20091106 SEE 20.81 21.15 20.71 20.96 11140 20091109 SEE 21.18 21.9 21.17 21.88 12952 20091110 SEE 21.81 21.97 21.72 21.8 13092 20091111 SEE 22 22.25 21.81 21.98 16459 20091112 SEE 22 22.35 21.6 21.65 14140 20091113 SEE 21.57 21.83 21.51 21.8 18831 20091116 SEE 21.91 22.54 21.91 22.41 14564 20091117 SEE 22.4 22.6 22.1509 22.53 11274 20091118 SEE 22.52 22.67 22.3 22.46 10740 20091119 SEE 22.13 22.31 21.85 22.12 8070 20091120 SEE 21.88 22.28 21.83 22.15 9008 20091123 SEE 22.52 22.82 22.48 22.59 9262 20091124 SEE 22.67 22.81 22.35 22.42 8416 20091125 SEE 22.46 22.82 22.41 22.65 10151 20091127 SEE 22.15 22.48 21.93 22.31 4266 20091130 SEE 22.24 22.42 22.07 22.29 9936 20091201 SEE 22.52 22.59 22.345 22.5 12473 20091202 SEE 22.44 22.75 22.38 22.65 13529 20091203 SEE 22.63 22.79 22.25 22.33 10835 20091204 SEE 22.75 22.99 22.27 22.62 11315 20091207 SEE 22.55 22.89 22.48 22.65 6648 20091208 SEE 22.58 22.6 22.26 22.39 9664 20091209 SEE 22.41 22.51 22.13 22.45 8564 20091210 SEE 22.61 22.71 22.28 22.32 10595 20091211 SEE 22.46 22.51 22.11 22.3 8475 20091214 SEE 22.39 22.39 22.18 22.27 10257 20091215 SEE 22.19 22.3 21.95 22.05 9208 20091216 SEE 22.09 22.28 21.94 22.06 7568 20091217 SEE 21.95 22.02 21.68 21.79 6829 20091218 SEE 21.88 21.98 21.45 21.75 14471 20091221 SEE 21.84 22.145 21.81 21.83 7793 20091222 SEE 21.83 22.03 21.66 21.69 10999 20091223 SEE 21.79 21.92 21.58 21.85 8857 20091224 SEE 21.91 22.24 21.9 22.2 2780 20091228 SEE 22.27 22.42 21.8 21.99 8377 20091229 SEE 22 22.2 21.97 22.09 5591 20091230 SEE 21.97 22.09 21.87 21.87 5835 20091231 SEE 21.95 22.11 21.76 21.86 7693 20100104 SEE 22.01 22.1 21.92 22.02 9203 20100105 SEE 21.99 22.08 21.63 21.79 8313 20100106 SEE 21.78 21.84 21.27 21.37 13343 20100107 SEE 21.34 21.62 21.25 21.59 13948 20100108 SEE 21.55 21.7 21.46 21.68 7028 20100111 SEE 21.81 21.94 21.55 21.67 6389 20100112 SEE 21.44 21.53 21.23 21.5 7246 20100113 SEE 21.46 21.61 21.25 21.5 5899 20100114 SEE 21.51 21.53 21.17 21.32 9132 20100115 SEE 21.26 21.32 21.08 21.12 8764 20100119 SEE 21.15 21.68 21.04 21.66 15749 20100120 SEE 21.56 21.59 21.2 21.35 10264 20100121 SEE 21.32 21.55 20.91 20.94 12995 20100122 SEE 20.82 21.03 20.41 20.44 13205 20100125 SEE 20.72 20.89 19.67 20.07 29799 20100126 SEE 19.91 20.36 19.79 20.07 19520 20100127 SEE 19.95 20.29 19.61 20.19 22578 20100128 SEE 20.32 20.32 19.68 19.77 17457 20100129 SEE 19.86 20.25 19.74 19.84 20208 20100201 SEE 19.97 20.19 19.69 19.9 20159 20100202 SEE 19.95 20.21 19.79 20.12 15589 20100203 SEE 19.94 20.06 19.42 19.68 13109 20100204 SEE 19.51 19.52 18.84 18.84 11821 20100205 SEE 18.86 19.07 18.43 19.05 14651 20100208 SEE 19.03 19.24 18.76 19.12 29294 20100209 SEE 19.41 19.67 19.12 19.44 17355 20100210 SEE 19.38 19.48 19.05 19.33 13711 20100211 SEE 19.3 19.63 19.18 19.62 19492 20100212 SEE 19.34 19.61 19.13 19.57 11547 20100216 SEE 19.71 19.79 19.6 19.74 10366 20100217 SEE 19.81 20.21 19.64 19.86 10968 20100218 SEE 19.8 20.19 19.76 20.12 7874 20100219 SEE 20.1 20.28 19.88 20.17 8129 20100222 SEE 20.24 20.31 20.04 20.27 8320 20100223 SEE 20.18 20.38 19.98 20.1 9713 20100224 SEE 20.11 20.33 20.04 20.31 7747 20100225 SEE 20.11 20.48 19.73 20.45 11373 20100226 SEE 20.52 20.53 20.16 20.43 15843 20100301 SEE 20.49 20.65 20.39 20.65 11787 20100302 SEE 20.75 20.85 20.62 20.78 10548 20100303 SEE 20.82 20.9 20.73 20.85 9386 20100304 SEE 20.81 20.9 20.31 20.53 14691 20100305 SEE 20.73 20.94 20.62 20.91 12077 20100308 SEE 20.93 21.14 20.74 20.88 13096 20100309 - ---- - -9.1 8.57 9.09 18684 20100611 NYT 8.95 9.23 8.93 9.18 10066 20100614 NYT 9.42 9.44 9.1 9.14 21276 20100615 NYT 9.29 9.76 9.22 9.76 16238 20100616 NYT 9.64 9.81 9.46 9.68 21348 20100617 NYT 9.81 9.9 9.58 9.89 15185 20100618 NYT 9.9 10 9.71 9.78 23204 20100621 NYT 9.96 10.46 9.96 10.13 26547 20100622 NYT 10.16 10.27 10 10.04 13403 20100623 NYT 10.03 10.09 9.58 9.62 16601 20100624 NYT 9.52 9.61 9.17 9.18 13037 20100625 NYT 9.2 9.69 9.07 9.4 39473 20100628 NYT 9.5 9.88 9.41 9.74 20413 20100629 NYT 9.49 9.6 8.93 9 14137 20100630 NYT 8.95 9.18 8.59 8.65 18097 20100701 NYT 8.64 8.82 8.38 8.64 16650 20100702 NYT 8.69 8.75 8.43 8.5 13811 20100706 NYT 8.65 8.88 8.5 8.57 20833 20100707 NYT 8.55 8.67 8.42 8.54 33181 20100708 NYT 8.68 9.1 8.61 8.94 23522 20100709 NYT 8.9 9.07 8.77 9.01 19021 20100712 NYT 9.01 9.48 8.98 9.39 24480 20100713 NYT 9.54 9.58 9.34 9.52 19051 20100714 NYT 9.51 9.62 9.39 9.59 14721 20100715 NYT 9.58 9.65 9.3 9.58 17623 20100716 NYT 9.52 9.52 8.75 8.8 23439 20100719 NYT 8.82 9.2 8.62 8.88 18242 20100720 NYT 8.7 9.37 8.6 9.34 25221 20100721 NYT 9.41 9.54 8.98 9.05 14154 20100722 NYT 9.37 9.55 8.92 9.16 32301 20100723 NYT 9.11 9.31 8.94 9.25 16162 20100726 NYT 9.26 9.75 9.22 9.74 19157 20100727 NYT 9.85 9.9 9.61 9.76 13183 20100728 NYT 9.7 9.7 8.97 8.99 25455 20100729 NYT 9.04 9.24 8.6 8.71 28695 20100730 NYT 8.56 8.91 8.21 8.74 25928 20100802 NYT 8.96 9.38 8.88 9.32 17762 20100803 NYT 9.22 9.31 8.88 8.9 12986 20100804 NYT 8.97 9.1 8.88 9.04 7275 20100805 NYT 8.95 9.02 8.865 8.98 8626 20100806 NYT 8.85 8.91 8.595 8.73 12829 20100809 NYT 8.8 8.97 8.67 8.71 7232 20100810 NYT 8.52 8.6 8.37 8.45 18258 20100811 NYT 8.26 8.44 8 8.03 17197 20100812 NYT 7.79 8.06 7.65 7.85 20572 20100813 NYT 7.83 7.98 7.669 7.71 12874 20100816 NYT 7.65 7.89 7.62 7.79 11931 20100817 NYT 7.9 8.22 7.78 8.1 18310 20100819 NYT 8.25 8.3 7.9 7.95 14467 20100820 NYT 7.85 7.89 7.59 7.72 11469 20090821 NYX 28.06 28.18 27.67 27.93 27067 20090824 NYX 28.13 28.37 27.62 27.68 29183 20090825 NYX 27.65 28.13 27.65 27.96 30513 20090826 NYX 27.8 28.83 27.76 28.79 34415 20090827 NYX 28.55 28.73 28.17 28.52 25638 20090828 NYX 28.68 28.69 28.04 28.46 18179 20090831 NYX 27.85 28.38 27.73 28.34 28077 20090901 NYX 28.11 28.24 27.04 27.1 44641 20090902 NYX 26.98 27.44 26.84 27.03 25544 20090903 NYX 27.25 27.4 26.94 27.32 20750 20090904 NYX 27.15 27.66 26.9 27.61 22686 20090909 NYX 28.07 28.35 27.75 28.28 27773 20090910 NYX 28.19 28.3 27.81 28.21 20776 20090911 NYX 28.14 28.14 27.74 27.78 30457 20090914 NYX 27.51 28.36 27.27 28.32 28040 20090915 NYX 28.47 29.56 28.25 29.23 38288 20090916 NYX 29.59 29.59 28.95 29.56 40270 20090917 NYX 29.41 30.14 29.28 29.84 37369 20090918 NYX 29.91 30.44 29.53 30.29 42690 20090921 NYX 29.92 30.09 29.25 29.42 29501 20090922 NYX 29.93 29.93 29.39 29.82 33211 20090923 NYX 29.8 29.99 29.05 29.15 28146 20090924 NYX 29.29 29.4699 28.0799 28.44 28328 20090925 NYX 28.19 28.45 27.83 28.02 23517 20090928 NYX 28.01 28.83 27.87 28.78 23907 20090929 NYX 28.76 29.15 28.61 28.74 16899 20090930 NYX 29.34 29.34 28.42 28.89 24753 20091001 NYX 28.9 28.9 27.72 27.76 26998 20091002 NYX 27.19 27.9 27.19 27.31 21909 20091005 NYX 27.54 28.18 27.4 28.13 26608 20091006 NYX 28.3 28.39 27.54 28.05 23106 20091007 NYX 27.83 28.74 27.7 28.71 30995 20091008 NYX 28.8 29.04 28.23 28.4 29853 20091009 NYX 28.26 28.38 27.72 28.11 27396 20091012 NYX 28.23 28.5 28.05 28.48 18908 20091013 NYX 28.32 28.5 28.06 28.32 16812 20091014 NYX 28.66 30 28.6508 29.9 57686 20091015 NYX 29.59 29.96 29.59 29.94 32368 20091016 NYX 29.51 29.83 29.12 29.2 34368 20091019 NYX 29.32 29.32 28.88 29.06 32343 20091020 NYX 29.09 29.25 28.66 28.97 31841 20091021 NYX 28.96 29.68 28.76 28.81 30632 20091022 NYX 28.85 29.35 28.59 29.33 28094 20091023 NYX 29.35 29.57 29.08 29.15 29169 20091026 NYX 29.24 29.79 28.16 28.26 37846 20091027 NYX 28.24 28.46 27.64 27.76 27989 20091028 NYX 27.6 27.88 26.82 26.83 36948 20091105 NYX 25.75 26.22 25.67 26.17 21978 20091106 NYX 25.92 27.18 25.88 26.87 33261 20091109 - ---- - -STJ 38.22 38.69 37.88 38.46 18865 20100811 STJ 38.03 38.05 37.18 37.28 17932 20100812 STJ 37.05 37.52 36.8 37.44 14716 20100813 STJ 37.3 37.52 37.21 37.23 11866 20100816 STJ 37.06 37.15 36.8 36.9 14050 20100817 STJ 37.14 37.79 37.04 37.56 11966 20100819 STJ 37.73 37.73 36.68 37.17 18540 20100820 STJ 36.88 37 36.13 36.58 20315 20090821 STR 34.24 34.9 33.9 34.79 14511 20090824 STR 35.01 35.53 34.9 35.18 11701 20090825 STR 35.36 35.54 34.65 34.78 8491 20090826 STR 34.36 34.92 34.14 34.65 5349 20090827 STR 34.43 34.6 33.6 34.42 7890 20090828 STR 34.58 35.02 34.27 34.9 12594 20090831 STR 34.14 34.25 33.47 33.76 8344 20090901 STR 33.53 34.29 33.14 33.26 10580 20090902 STR 33.04 33.5 32.95 33.16 10409 20090903 STR 33.43 33.43 32.72 33.01 8990 20090904 STR 33.04 33.52 32.96 33.48 6982 20090909 STR 34.3 34.67 34.02 34.38 11943 20090910 STR 34.38 35.33 34.14 35.22 11996 20090911 STR 35.3 36.06 35.23 35.65 12984 20090914 STR 34.01 35.42 33.76 35.25 11587 20090915 STR 35.39 35.76 35.26 35.67 9023 20090916 STR 35.91 36.9 35.64 36.88 13047 20090917 STR 36.91 37.51 36.69 37.04 12831 20090918 STR 37.42 37.42 36.48 36.85 20282 20090921 STR 36 36.35 35.21 36.11 10933 20090922 STR 36.66 37.49 36.46 37.24 16446 20090923 STR 37.23 37.3625 36.28 36.36 12323 20090924 STR 36.45 36.58 35.64 35.99 11807 20090925 STR 35.78 36.35 35.75 36.16 14139 20090928 STR 36.23 36.99 36.2 36.89 10781 20090929 STR 36.91 37.72 36.69 37.59 12502 20090930 STR 37.51 37.89 36.92 37.56 18640 20091001 STR 37.59 37.59 35.74 35.74 16626 20091002 STR 35.2 35.74 34.98 35.45 12049 20091005 STR 35.44 36.95 35.37 36.88 15356 20091006 STR 37.32 37.99 37.17 37.58 12460 20091007 STR 37.42 37.77 37.25 37.64 7974 20091008 STR 37.88 38.9 37.68 38.89 16509 20091009 STR 38.52 38.8 38.41 38.64 13574 20091012 STR 39 39.47 38.87 39.01 8811 20091013 STR 39.01 39.15 38.22 39.04 11899 20091014 STR 39.48 39.71 38.98 39.3 12379 20091015 STR 39.1 40.91 39.01 40.89 19713 20091016 STR 40.54 41.13 40.48 40.86 15330 20091019 STR 40.87 42.26 40.68 42.16 13027 20091020 STR 41.98 42.33 41.54 42.22 17530 20091021 STR 41.96 43.46 41.95 42.35 17210 20091022 STR 42.35 42.42 41.7601 42.02 14729 20091023 STR 42.14 42.43 40.79 41.15 12768 20091026 STR 41.17 42.17 40.24 40.39 15846 20091027 STR 40.64 41.43 40.28 40.59 9934 20091028 STR 41.2 42.06 39.83 39.94 26904 20091105 STR 40.75 41.18 40.34 41.01 10297 20091106 STR 40.65 41.27 40.29 40.65 8961 20091109 STR 41.74 42.79 41.74 42.28 17753 20091110 STR 41.93 42.77 41.93 42.52 17106 20091111 STR 42.84 43.15 42.35 42.59 16352 20091112 STR 42.47 43 41.95 42.04 25262 20091113 STR 42.23 42.65 41.66 42.23 12768 20091116 STR 42.68 43.2 42.53 43.01 12425 20091117 STR 42.94 42.95 42.47 42.56 10027 20091118 STR 42.25 42.5 41.38 41.49 12269 20091119 STR 41.25 41.4 39.94 40.18 11201 20091120 STR 39.83 40.15 39.18 39.59 19016 20091123 STR 40.41 40.93 39.92 40.17 9220 20091124 STR 40.04 40.17 38.96 39.49 17242 20091125 STR 39.65 40.67 39.315 40.35 13454 20091127 STR 39.34 39.83 38.88 39.35 4678 20091130 STR 39.38 39.81 39.17 39.67 12891 20091201 STR 40.24 40.79 40.13 40.5 9209 20091202 STR 40.55 41.1897 40.55 40.77 10169 20091203 STR 40.91 41.19 40.15 40.22 8827 20091204 STR 40.95 41.17 39.43 40.01 14232 20091207 STR 39.91 40.35 39.5 39.57 17629 20091208 STR 39.14 39.17 37.94 38.13 19939 20091209 STR 38.15 38.41 37.5119 38.09 11852 20091210 STR 38.44 39.03 38.27 38.75 12441 20091211 STR 38.95 39.37 38.87 39.22 14864 20091214 STR 39.79 40.7 39.76 40.54 13312 20091215 STR 40.41 40.82 40.17 40.6 7607 20091216 STR 40.91 41.14 40.53 40.88 9786 20091217 STR 40.74 41.36 40.2 41.26 16581 20091218 STR 41.76 42.081 41.37 41.59 18415 20091221 STR 41.92 42.41 41.86 42.33 10057 20091222 STR 42.23 42.6 41.909 42.13 8964 20091223 STR 42.26 42.66 42 42.5 5725 20091224 STR 42.49 42.83 42.43 42.8 2412 20091228 STR 43.26 43.26 42.7 43.03 5533 20091229 STR 43.1 43.2137 42.75 42.85 6125 20091230 STR 42.81 42.81 42.03 42.23 6563 20091231 STR 42.47 42.56 41.5 41.57 4839 20100104 STR 42.57 43.26 - ---- - -22.99 23.37 160352 20100609 LOW 23.53 23.7601 23.16 23.28 116867 20100610 LOW 23.57 23.86 23.4 23.84 123065 20100611 LOW 23.59 23.83 23.23 23.48 104957 20100614 LOW 23.68 23.9075 23.39 23.45 100970 20100615 LOW 23.65 23.93 23.2 23.93 99645 20100616 LOW 23.67 23.73 22.95 23.2 182355 20100617 LOW 23.24 23.26 22.36 22.68 223206 20100618 LOW 22.7 22.97 22.53 22.62 301223 20100621 LOW 22.81 22.98 22.44 22.51 134612 20100622 LOW 22.665 22.73 21.73 21.76 202842 20100623 LOW 21.71 22.12 21.42 21.85 139783 20100624 LOW 21.35 21.625 21.06 21.24 159024 20100625 LOW 21.21 21.6 21.12 21.33 212729 20100628 LOW 21.38 21.49 21.17 21.23 80098 20100629 LOW 20.94 20.98 20.5 20.6 166783 20100630 LOW 20.58 20.86 20.36 20.42 113430 20100701 LOW 20.52 20.76 20.02 20.41 225985 20100702 LOW 20.53 20.54 20.01 20.27 119216 20100706 LOW 20.44 20.64 19.74 19.96 160622 20100707 LOW 20.04 20.42 19.64 20.39 185841 20100708 LOW 20.54 20.64 20.04 20.23 143875 20100709 LOW 20.22 20.44 20.02 20.43 197086 20100712 LOW 20.36 20.5 20.11 20.36 172376 20100713 LOW 20.55 21.305 20.47 21.16 177748 20100714 LOW 21.09 21.09 20.64 20.87 111204 20100715 LOW 20.89 20.95 20.5 20.88 95841 20100716 LOW 20.79 20.79 19.99 20.04 147780 20100719 LOW 20.03 20.06 19.75 19.93 82188 20100720 LOW 19.71 20.42 19.64 20.33 115111 20100721 LOW 20.4 20.41 19.86 19.98 101414 20100722 LOW 20.2 20.93 20.17 20.83 138123 20100723 LOW 20.76 21.14 20.59 21.11 122497 20100726 LOW 21.23 21.82 21.08 21.8 126023 20100727 LOW 21.91 21.99 21.04 21.15 149932 20100728 LOW 21.08 21.31 20.57 20.7 112100 20100729 LOW 20.98 21.01 20.13 20.48 145010 20100730 LOW 20.31 20.81 20.19 20.74 116941 20100802 LOW 21.05 21.4 20.81 21.33 93576 20100803 LOW 21.16 21.28 20.65 20.74 119300 20100804 LOW 20.92 21.13 20.81 20.81 112620 20100805 LOW 20.72 20.94 20.47 20.74 109540 20100806 LOW 20.52 20.62 20.2 20.28 156744 20100809 LOW 20.39 20.46 20.29 20.31 109914 20100810 LOW 20.16 20.19 19.82 19.92 134298 20100811 LOW 19.74 19.92 19.35 19.81 191072 20100812 LOW 19.58 19.83 19.45 19.74 99409 20100813 LOW 19.62 20.06 19.55 19.59 138054 20100816 LOW 20.08 20.3697 19.58 19.7 259945 20100817 LOW 20.01 20.34 19.78 19.99 182105 20100819 LOW 20.62 20.845 20.13 20.4 178239 20100820 LOW 20.27 20.72 20.18 20.64 120403 20090821 LSI 4.94 5.06 4.89 5.05 77193 20090824 LSI 5.07 5.2 5.05 5.08 55204 20090825 LSI 5.08 5.16 4.99 5.07 60206 20090826 LSI 5.05 5.15 5 5.08 42306 20090827 LSI 5.07 5.22 5 5.2 61521 20090828 LSI 5.23 5.45 5.23 5.29 64552 20090831 LSI 5.2 5.26 5.12 5.21 52538 20090901 LSI 5.17 5.38 5.02 5.04 76044 20090902 LSI 5.02 5.1 4.91 4.94 85101 20090903 LSI 4.97 5.01 4.93 5.01 32580 20090904 LSI 5.01 5.16 4.99 5.16 38915 20090909 LSI 5.37 5.53 5.3 5.38 100094 20090910 LSI 5.38 5.58 5.34 5.53 84444 20090911 LSI 5.54 5.56 5.415 5.48 55652 20090914 LSI 5.42 5.59 5.38 5.58 56156 20090915 LSI 5.6 5.78 5.58 5.69 90916 20090916 LSI 5.69 5.75 5.51 5.53 110743 20090917 LSI 5.49 5.55 5.41 5.47 78234 20090918 LSI 5.51 5.56 5.38 5.45 71154 20090921 LSI 5.39 5.45 5.3 5.34 72996 20090922 LSI 5.43 5.52 5.32 5.47 58321 20090923 LSI 5.58 5.62 5.45 5.46 78412 20090924 LSI 5.53 5.53 5.27 5.3 64011 20090925 LSI 5.45 5.64 5.3 5.58 125164 20090928 LSI 5.61 5.7 5.56 5.65 50806 20090929 LSI 5.61 5.72 5.44 5.46 84808 20090930 LSI 5.49 5.61 5.35 5.49 80427 20091001 LSI 5.45 5.49 5.29 5.31 122493 20091002 LSI 5.25 5.36 5.17 5.22 88933 20091005 LSI 5.27 5.49 5.23 5.46 92468 20091006 LSI 5.51 5.61 5.48 5.54 96440 20091007 LSI 5.53 5.62 5.48 5.58 61889 20091008 LSI 5.65 5.66 5.37 5.44 140711 20091009 LSI 5.55 5.67 5.48 5.67 126626 20091012 LSI 5.62 5.84 5.58 5.71 137981 20091013 LSI 5.71 5.85 5.65 5.79 134262 20091014 LSI 5.98 6.06 5.9 5.96 156742 20091015 LSI 5.93 5.96 5.69 5.75 101231 20091016 LSI 5.67 5.75 5.52 5.63 109994 20091019 LSI 5.72 5.77 5.57 5.73 110598 20091020 LSI 5.79 5.83 5.64 5.68 64299 20091021 LSI 5.62 5.77 5.5 5.51 87070 20091022 LSI 5.57 5.58 5.4 5.46 112487 20091023 LSI 5.56 5.63 5.31 5.35 103364 20091026 LSI 5.3 5.54 5.26 5.33 79343 - ---- - -16.51 16.64 16.05 16.06 81022 20100322 GCI 16.01 16.49 15.74 16.42 38887 20100323 GCI 16.49 16.8 16.19 16.72 30814 20100324 GCI 16.59 16.64 16.29 16.55 32863 20100325 GCI 16.62 16.96 16.47 16.5 33481 20100326 GCI 16.56 16.885 16.33 16.54 26462 20100329 GCI 16.67 17 16.52 16.72 29556 20100330 GCI 16.73 16.92 16.675 16.86 27969 20100331 GCI 16.8 16.8906 16.43 16.52 33025 20100401 GCI 16.44 16.8 16.42 16.7 26426 20100405 GCI 16.79 17.3 16.72 17.24 28073 20100406 GCI 17.15 17.539 17.03 17.34 41813 20100407 GCI 17.21 17.83 17.12 17.52 63429 20100408 GCI 17.4 17.9 17.12 17.79 43814 20100409 GCI 17.77 18.0199 17.67 17.79 34032 20100412 GCI 17.8 18.15 17.5 18.11 40277 20100413 GCI 17.95 18.04 17.66 17.74 36158 20100414 GCI 17.99 18.11 17.78 17.98 48134 20100415 GCI 17.93 18.545 17.76 18.14 61579 20100416 GCI 18.93 19.69 18 18.04 173981 20100419 GCI 18.11 18.28 17.26 17.81 83915 20100420 GCI 18 18.53 18 18.43 60700 20100421 GCI 18.51 18.73 18.29 18.42 55227 20100422 GCI 18.29 18.35 17.82 18.28 35992 20100423 GCI 18.3 18.41 18 18.28 36698 20100426 GCI 18.36 18.85 18.21 18.67 61713 20100427 GCI 18.46 18.56 17.47 17.56 63447 20100428 GCI 17.67 17.86 17.03 17.4 52864 20100429 GCI 17.58 17.63 17.29 17.5 54103 20100430 GCI 17.54 17.66 16.83 17.02 54484 20100503 GCI 17.14 17.4 16.995 17.29 60592 20100504 GCI 16.68 16.97 16.45 16.58 52086 20100505 GCI 16.27 16.7 15.92 16.29 40582 20100506 GCI 16.08 16.39 14.12 15.58 93252 20100507 GCI 15.5 15.62 14.33 15.05 116845 20100510 GCI 16.01 16.04 15.51 16.04 105287 20100511 GCI 15.7 17.2725 15.7 16.59 81192 20100512 GCI 16.65 17.15 16.44 17.07 48062 20100513 GCI 17.08 17.08 16.33 16.44 43387 20100514 GCI 16.24 16.34 15.4701 15.76 45444 20100517 GCI 15.8 16.45 15.58 16.19 50606 20100518 GCI 16.45 16.66 15.41 15.56 45868 20100519 GCI 15.41 15.52 14.7 15.3 54429 20100520 GCI 14.8 15.43 14.55 14.88 71465 20100521 GCI 14.54 15.04 14.38 14.58 84911 20100524 GCI 14.52 14.96 14.38 14.64 47797 20100525 GCI 14.08 14.71 13.93 14.7 54996 20100526 GCI 14.93 15.46 14.78 14.91 55608 20100527 GCI 15.42 15.88 15.24 15.86 32093 20100528 GCI 15.87 16.05 15.5 15.54 37606 20100601 GCI 15.27 15.36 14.52 14.54 55649 20100602 GCI 14.71 14.86 14.43 14.8 58042 20100603 GCI 14.93 15.09 14.47 14.85 34379 20100604 GCI 14.35 14.5 13.66 13.73 64696 20100607 GCI 13.87 14.45 13.48 14.29 122480 20100608 GCI 14.33 14.81 14.08 14.52 84025 20100609 GCI 14.75 15.11 14.42 14.53 67832 20100610 GCI 14.92 15.43 14.83 15.42 31113 20100611 GCI 15.18 16.07 15.18 16.04 40636 20100614 GCI 16.41 16.41 15.74 15.78 46658 20100615 GCI 16.05 16.645 15.97 16.61 27629 20100616 GCI 16.39 16.59 16.12 16.47 36355 20100617 GCI 16.62 16.62 16.05 16.41 33365 20100618 GCI 16.44 16.81 16.37 16.65 27161 20100621 GCI 16.98 17.22 16.44 16.56 34934 20100622 GCI 16.56 16.79 16.33 16.34 40362 20100623 GCI 16.32 16.41 15.72 15.88 44566 20100624 GCI 15.73 15.77 14.86 14.94 48077 20100625 GCI 15 15.04 14.64 14.88 39172 20100628 GCI 14.83 15.28 14.8 14.95 31194 20100629 GCI 14.65 14.72 13.84 14.04 49658 20100630 GCI 13.88 14.31 13.37 13.46 46066 20100701 GCI 13.31 13.51 12.54 13.36 78656 20100702 GCI 13.43 13.52 13.02 13.13 36036 20100706 GCI 13.35 13.71 12.97 13.13 39922 20100707 GCI 13.21 14.17 13.2 14.16 51740 20100708 GCI 14.36 14.53 14.17 14.49 33753 20100709 GCI 14.5 14.88 14.33 14.84 30608 20100712 GCI 14.79 14.935 14.305 14.62 40393 20100713 GCI 14.91 14.91 14.56 14.73 34483 20100714 GCI 14.67 14.97 14.38 14.77 54531 20100715 GCI 14.78 15.17 14.63 15.11 46613 20100716 GCI 14.63 14.68 13.39 13.5 128600 20100719 GCI 13.38 14 13.335 13.99 67691 20100720 GCI 13.64 14.19 13.52 14.12 56232 20100721 GCI 14.25 14.34 13.38 13.46 49683 20100722 GCI 13.76 13.88 13.31 13.48 60612 20100723 GCI 13.57 14.15 13.49 14.06 56332 20100726 GCI 14.09 14.81 14 14.52 54627 20100727 GCI 14.69 14.76 14.08 14.23 40648 20100728 GCI 14.185 14.37 13.77 13.9 28940 20100729 GCI 14.04 14.18 13.1 13.25 63195 20100730 GCI 13.02 13.275 12.88 13.18 39478 20100802 GCI 13.51 13.86 13.31 13.69 42775 - ---- - -49.12 49.14 21092 20090925 K 49.13 49.24 48.79 49.09 13976 20090928 K 49.22 49.76 49.01 49.62 17630 20090929 K 49.64 49.82 49.27 49.45 10776 20090930 K 49.49 49.49 48.8 49.23 17967 20091001 K 49.1 49.11 48.34 48.88 15669 20091002 K 48.84 48.86 48.45 48.66 12993 20091005 K 48.67 48.99 48.15 48.96 12740 20091006 K 49.12 49.69 48.97 49.3 14834 20091007 K 49.21 49.46 49.124 49.37 10994 20091008 K 49.5 49.77 49.345 49.74 18660 20091009 K 49.62 49.95 49.45 49.82 17085 20091012 K 49.9 49.98 49.47 49.68 13786 20091013 K 49.65 49.86 49.47 49.58 17195 20091014 K 49.72 49.76 49.3 49.58 19572 20091015 K 49.37 50.18 49.37 50.18 18539 20091016 K 49.89 50.67 49.78 50.48 26214 20091019 K 50.63 51.19 50.47 51.01 12787 20091020 K 51.03 51.32 50.56 50.68 17952 20091021 K 50.74 51.41 50.55 50.66 15326 20091022 K 50.715 50.87 50.09 50.64 17055 20091023 K 50.75 50.8 49.83 50.2 16667 20091026 K 50.3 51.11 50.1 50.45 19335 20091027 K 50.41 50.85 50.31 50.42 22638 20091028 K 50.2 50.78 49.87 49.99 28357 20091105 K 51.86 52.28 51.65 52.23 25153 20091106 K 52.1 52.42 51.83 52.2 19293 20091109 K 52.35 52.7 52.21 52.67 16021 20091110 K 52.49 53 52.49 52.82 16081 20091111 K 53.12 53.12 52.51 52.74 13443 20091112 K 52.82 53.04 52.65 52.96 17265 20091113 K 53.39 53.39 52.93 53.37 18794 20091116 K 53.45 53.8 53.21 53.39 23707 20091117 K 53.5 53.57 53.05 53.4 14664 20091118 K 53.31 53.49 52.9 53.34 11692 20091119 K 53.18 53.18 52.49 52.98 10742 20091120 K 53.03 53.47 52.89 53.12 19322 20091123 K 53.69 54 53.47 53.87 15866 20091124 K 53.79 54 53.49 53.91 16162 20091125 K 54.05 54.05 53.52 53.66 12570 20091127 K 52.86 53.13 52.63 52.97 9565 20091130 K 52.59 52.64 52.15 52.58 28666 20091201 K 52.7 53.2 52.66 52.97 17271 20091202 K 52.82 53.38 52.78 53 21660 20091203 K 52.99 53.09 52.58 52.73 21537 20091204 K 52.94 53.17 52.6 52.96 13309 20091207 K 53.07 53.17 52.78 52.89 14845 20091208 K 52.79 52.88 52.07 52.62 23138 20091209 K 52.65 52.96 52.55 52.8 19044 20091210 K 52.98 53.15 52.88 52.99 19212 20091211 K 53.01 53.97 53.01 53.7 22131 20091214 K 53.87 53.87 53.55 53.57 15271 20091215 K 53.64 53.65 53.08 53.12 20377 20091216 K 53.21 53.6 52.65 52.77 15708 20091217 K 52.75 52.75 52.07 52.14 15637 20091218 K 52.25 52.5 51.55 52.27 31794 20091221 K 52.27 52.48 52.11 52.17 15669 20091222 K 52.34 52.9 52.08 52.84 10675 20091223 K 53.14 53.5 53 53.3 15557 20091224 K 53.47 54.01 53.35 54 10351 20091228 K 53.91 53.97 53.715 53.96 6416 20091229 K 53.97 54.08 53.83 53.98 10684 20091230 K 53.95 54.1 53.6901 53.99 8079 20091231 K 53.96 53.96 53.17 53.2 7381 20100104 K 53.31 53.57 52.57 52.83 27489 20100105 K 52.8 52.98 52.55 52.95 14719 20100106 K 52.82 53.14 52.6 52.96 14942 20100107 K 52.78 53.52 52.7 53.48 17828 20100108 K 53.3 53.38 53 53.38 13426 20100111 K 53.51 53.72 53.03 53.41 9439 20100112 K 53.15 53.65 53.14 53.39 14637 20100113 K 53.46 53.99 53.46 53.72 14052 20100114 K 53.94 54.11 53.6 53.85 16383 20100115 K 54.5 54.96 54.1 54.34 37813 20100119 K 54.28 54.6 54.28 54.5 14372 20100120 K 54.08 54.43 53.5 53.87 18695 20100121 K 53.97 54.46 53.16 53.44 24010 20100122 K 53.28 54.61 53.24 54.34 48319 20100125 K 54.44 54.57 54.12 54.17 23397 20100126 K 54.06 54.86 53.82 54.85 29060 20100127 K 54.76 55.28 54.7 55.05 34845 20100128 K 55.03 55.45 54.14 54.81 24398 20100129 K 54.97 54.98 54.27 54.42 33342 20100201 K 54.79 54.88 54.34 54.72 33890 20100202 K 54.58 55.39 54.44 55.36 32712 20100203 K 55.3 55.41 54.9405 55.19 28370 20100204 K 53.82 54.43 52.41 52.41 65021 20100205 K 52.19 53.02 52.06 52.72 44629 20100208 K 52.82 52.82 51.99 52.01 21024 20100209 K 52.29 52.88 52.14 52.49 21925 20100210 K 52.55 52.62 52.2201 52.33 20018 20100211 K 52.41 52.66 51.93 52.62 19188 20100212 K 52.39 52.79 52.2 52.34 31789 20100216 K 52.6 52.68 51.91 52.6 25510 20100217 K 52.66 52.98 52.45 52.98 23045 20100218 K 53.04 53.12 52.78 53.01 14588 20100219 K 52.93 53.4 52.81 53.2 19851 20100222 K 53.15 53.32 52.74 52.86 25770 20100223 K 52.89 53.06 52.37 52.73 23446 20100224 K 52.8 53.32 52.15 - ---- - -.dir-locals.el -.check.translations.R -^\.Rprofile$ -^data\.table_.*\.tar\.gz$ -^config\.log$ -^vignettes/plots/figures$ -^\.Renviron$ -^[^/]+\.R$ -^[^/]+\.csv$ -^[^/]+\.csvy$ -^[^/]+\.RDS$ -^[^/]+\.diff$ -^[^/]+\.patch$ - -^\.ci$ -^\.dev$ -^\.devcontainer$ -^\.graphics$ -^\.github$ -^\.jj$ -^\.vscode$ -^\.zed$ -^\.lintr$ - -^\.gitlab-ci\.yml$ - -^Makefile$ -^NEWS\.0\.md$ -^NEWS\.1\.md$ -^src/Makevars$ -^CODEOWNERS$ -^GOVERNANCE\.md$ -^Seal_of_Approval\.md$ - -^\.RData$ -^\.Rhistory$ - -^\.emacs\.desktop -^\.emacs\.desktop\.lock -^.*\.Rproj$ -^\.Rproj\.user$ -^\.idea$ -^\.libs$ - -^.*\.dll$ - -^bus$ -^docs$ -^lib$ -^library$ -^devwd$ -^site$ - -# only the inst/po compressed files are needed, not raw .pot/.po -^po$ - ---- - -31.75 32.13 31.64 31.8 14100 20091124 DRI 31.92 31.92 31.12 31.37 22906 20091125 DRI 31.33 31.43 30.8 31.11 28176 20091127 DRI 30.46 31.36 30.34 31.15 8061 20091130 DRI 31.11 31.5 30.95 31.43 19134 20091201 DRI 31.77 32.1 31.33 31.83 16763 20091202 DRI 31.83 32.46 31.69 32.31 20835 20091203 DRI 32.16 32.3 31.57 31.64 18381 20091204 DRI 32.14 32.5 31.55 32.21 19630 20091207 DRI 32.24 32.43 32.05 32.15 9846 20091208 DRI 31.84 32.25 31.71 31.91 14668 20091209 DRI 31.93 32.2 31.73 31.94 14328 20091210 DRI 32.2 32.58 32.07 32.13 20524 20091211 DRI 32.41 32.62 32.27 32.45 23368 20091214 DRI 32.63 32.65 32.26 32.32 28599 20091215 DRI 32.36 32.94 32.11 32.56 21992 20091216 DRI 33.5 33.91 33.05 33.36 32985 20091217 DRI 33.04 33.25 32.67 32.75 22785 20091218 DRI 33.01 35.18 33 35.13 61671 20091221 DRI 35.09 35.92 34.96 35.65 24786 20091222 DRI 35.6 36.1 35.52 35.92 22441 20091223 DRI 36.12 36.12 35.51 35.94 15015 20091224 DRI 35.86 35.9601 35.54 35.93 6156 20091228 DRI 35.85 35.93 35.15 35.44 19391 20091229 DRI 35.61 35.96 35.45 35.52 10718 20091230 DRI 35.5 35.57 35.1 35.23 13950 20091231 DRI 35.25 35.49 35.04 35.07 11751 20100104 DRI 35.44 35.44 34.711 35 22280 20100105 DRI 35.06 35.07 34.21 34.85 27351 20100106 DRI 34.77 34.77 34.37 34.39 30944 20100107 DRI 34.46 35.03 34.2 34.71 24871 20100108 DRI 34.53 34.74 34.09 34.13 22681 20100111 DRI 34.42 34.42 33.835 34.04 14790 20100112 DRI 33.79 34.28 33.72 33.88 14303 20100113 DRI 33.92 34.18 33.75 34.11 10596 20100114 DRI 34.02 35.95 33.98 35.77 36455 20100115 DRI 35.86 35.86 35.07 35.3 23711 20100119 DRI 35.35 35.89 35.25 35.84 16417 20100120 DRI 36.56 37.86 36.25 36.53 35857 20100121 DRI 36.6 37.25 36.47 36.55 25905 20100122 DRI 36.34 36.84 36.08 36.16 24595 20100125 DRI 36.42 36.4395 35.86 36.01 19196 20100126 DRI 35.97 36.95 35.93 36.48 28124 20100127 DRI 36.48 36.76 36.25 36.62 23458 20100128 DRI 36.75 37.59 36.69 37.45 38680 20100129 DRI 37.45 37.75 36.83 36.96 35364 20100201 DRI 37.15 37.92 37.03 37.85 28264 20100202 DRI 37.87 38.64 37.64 38.29 23519 20100203 DRI 38.37 38.5 37.88 38.02 16000 20100204 DRI 37.71 38.07 37.36 37.4 33265 20100205 DRI 37.48 38 37 37.59 26312 20100208 DRI 37.66 38.07 37.51 37.53 17258 20100209 DRI 37.89 38.59 37.71 38.41 18520 20100210 DRI 38.36 38.48 37.96 38.05 20402 20100211 DRI 37.91 38.76 37.64 38.76 23354 20100212 DRI 38.33 39.05 38.09 38.99 20694 20100216 DRI 40.12 40.87 40.04 40.41 45344 20100217 DRI 40.71 40.99 40.48 40.59 19796 20100218 DRI 40.5 40.75 40.33 40.52 15006 20100219 DRI 40.59 41.0582 40.49 41.05 16426 20100222 DRI 41.18 41.2 40.73 41.05 14405 20100223 DRI 40.95 41.339 40.4 40.62 20614 20100224 DRI 40.86 41 40.63 40.99 13735 20100225 DRI 40.54 40.6 39.9 40.33 30512 20100226 DRI 40.43 40.715 40.33 40.55 12683 20100301 DRI 40.67 41.28 40.3 41.15 16133 20100302 DRI 41.22 41.39 40.45 40.51 28815 20100303 DRI 40.72 41 40.49 40.59 16487 20100304 DRI 40.64 40.78 40.25 40.45 19890 20100305 DRI 40.6 41 40.56 40.98 20427 20100308 DRI 41.06 42.255 41 41.99 21752 20100309 DRI 41.83 42.58 41.78 42.03 20776 20100310 DRI 41.94 42.28 41.59 42.25 14154 20100311 DRI 42.05 42.655 41.98 42.28 15848 20100312 DRI 42.37 42.48 41.7 42.02 26284 20100315 DRI 42 42.59 41.93 42.44 22945 20100316 DRI 42.47 42.88 42.19 42.6 25240 20100317 DRI 42.82 43.58 42.72 43.49 18773 20100318 DRI 43.61 43.98 43.32 43.49 17252 20100319 DRI 43.58 43.925 43.55 43.65 18729 20100322 DRI 43.47 44.19 43.3 44.13 18052 20100323 DRI 44.11 44.16 43.08 43.91 30286 20100324 DRI 43.67 45.07 42.91 44.91 55459 20100325 DRI 45.28 45.28 44.55 44.69 26397 20100326 DRI 44.35 44.74 43.99 44.29 27610 20100329 DRI 44.32 45 44.28 44.97 20185 20100330 DRI 44.84 45.29 44.55 44.8 15360 20100331 DRI 44.6 44.84 44.18 44.54 16464 20100401 DRI 44.8 45.01 44.045 44.5 17174 20100405 DRI 44.5 45.51 44.5 45.51 14084 20100406 DRI 45.44 45.45 44.96 45.26 17780 20100407 DRI 45.79 46.55 45.5 46.39 49677 20100408 DRI 46.36 46.65 45.99 46.38 23602 20100409 DRI 46.37 46.8 45.96 46.8 18855 20100412 DRI 46.71 47.05 - ---- - -9.04 58172 20091208 PHM 8.99 9.13 8.85 8.88 63767 20091209 PHM 9.01 9.05 8.81 8.93 53366 20091210 PHM 9 9.05 8.74 8.84 100737 20091211 PHM 8.87 8.89 8.72 8.83 122687 20091214 PHM 8.91 8.97 8.74 8.93 55038 20091215 PHM 8.92 9.03 8.84 8.89 66294 20091216 PHM 9.06 9.38 8.97 9.34 89009 20091217 PHM 9.22 9.33 9.11 9.22 57040 20091218 PHM 9.28 9.49 9.15 9.28 90245 20091221 PHM 9.37 9.46 9.23 9.42 67381 20091222 PHM 9.49 10.03 9.4 9.86 118835 20091223 PHM 10.01 10.17 9.96 10.06 110059 20091224 PHM 10.15 10.19 10.04 10.15 18685 20091228 PHM 10.16 10.18 9.81 9.87 47665 20091229 PHM 9.86 10 9.7 9.97 40489 20091230 PHM 9.92 10.08 9.8211 10.05 40606 20091231 PHM 10.03 10.14 9.94 10 46148 20100104 PHM 10.02 10.26 9.99 10.24 61212 20100105 PHM 10.23 10.39 10 10.37 70359 20100106 PHM 10.34 10.49 10.19 10.37 53687 20100107 PHM 10.62 11.33 10.58 11.21 194440 20100108 PHM 11.13 11.27 10.91 11.03 88292 20100111 PHM 11.03 11.2 10.89 10.97 58832 20100112 PHM 10.87 10.92 10.58 10.9 58518 20100113 PHM 10.84 11.36 10.815 11.32 104557 20100114 PHM 11.31 11.41 11.15 11.23 63572 20100115 PHM 11.25 11.31 10.93 11 50895 20100119 PHM 10.97 11.13 10.88 10.99 62647 20100120 PHM 10.91 11.01 10.75 10.9 66758 20100121 PHM 10.9 10.97 10.49 10.52 117341 20100122 PHM 10.49 10.78 10.19 10.22 88657 20100125 PHM 10.33 10.4 10.03 10.23 98523 20100126 PHM 10.18 10.44 10.14 10.35 78340 20100127 PHM 10.31 10.37 10.05 10.33 111407 20100128 PHM 10.4 10.65 10.17 10.56 102531 20100129 PHM 10.61 10.83 10.5 10.52 100023 20100201 PHM 10.51 10.57 10.34 10.56 69527 20100202 PHM 10.82 11.41 10.81 11.35 110063 20100203 PHM 11.71 11.79 11.23 11.37 85136 20100204 PHM 11.22 11.25 10.89 10.92 77292 20100205 PHM 10.9 10.955 10.52 10.88 110508 20100208 PHM 10.92 11.46 10.7 11.13 100927 20100209 PHM 11.07 11.25 10.63 11.08 175603 20100210 PHM 11.03 11.37 10.84 11.23 139110 20100211 PHM 11.2 11.75 11.14 11.71 87907 20100212 PHM 11.54 11.8 11.48 11.74 65479 20100216 PHM 11.46 11.66 11.27 11.66 78489 20100217 PHM 11.73 11.82 11.41 11.61 65817 20100218 PHM 11.62 11.62 11.37 11.49 43280 20100219 PHM 11.43 11.58 11.35 11.43 53653 20100222 PHM 11.44 11.59 11.26 11.38 43995 20100223 PHM 11.4 11.48 10.85 10.97 67413 20100224 PHM 11.04 11.1 10.5 10.81 90539 20100225 PHM 10.57 10.75 10.5 10.7 62690 20100226 PHM 10.69 10.88 10.45 10.83 61456 20100301 PHM 10.88 11.0154 10.83 10.92 40181 20100302 PHM 10.99 11.08 10.76 10.77 41298 20100303 PHM 10.77 11.02 10.7675 10.93 40128 20100304 PHM 10.9 11.06 10.79 10.87 34591 20100305 PHM 10.99 11.27 10.88 11.23 54111 20100308 PHM 11.28 11.49 11.15 11.42 65395 20100309 PHM 11.34 11.63 11.32 11.49 48542 20100310 PHM 11.5 11.61 11.27 11.36 59221 20100311 PHM 11.33 11.42 11.09 11.41 48948 20100312 PHM 11.49 11.49 11.15 11.23 49085 20100315 PHM 11.2 11.27 10.97 11.1 35975 20100316 PHM 11.11 11.5 11.05 11.39 57202 20100317 PHM 11.44 11.57 11.39 11.47 53109 20100318 PHM 11.48 11.6 11.39 11.5 44182 20100319 PHM 11.32 11.65 11.19 11.2 89108 20100322 PHM 11.15 11.52 11.06 11.47 68153 20100323 PHM 11.52 11.53 11.2 11.47 80486 20100324 PHM 11.56 11.81 11.5 11.65 93788 20100325 PHM 11.78 11.91 11.59 11.61 66568 20100326 PHM 11.65 11.9 11.6 11.72 62668 20100329 PHM 11.76 11.79 11.5 11.62 41491 20100330 PHM 11.6 11.78 11.39 11.43 44214 20100331 PHM 11.4 11.46 11.22 11.25 53449 20100401 PHM 11.37 11.46 11.07 11.12 54729 20100405 PHM 11.33 11.6 11.2 11.44 64200 20100406 PHM 11.09 11.25 10.91 11.16 66706 20100407 PHM 11.15 11.17 10.77 10.88 86142 20100408 PHM 10.86 10.97 10.7 10.89 68624 20100409 PHM 10.93 11.18 10.91 11.17 59672 20100412 PHM 11.25 11.3 11.05 11.23 55361 20100413 PHM 11.2 11.3 10.99 11.03 61814 20100414 PHM 11.08 11.45 11.04 11.38 69244 20100415 PHM 11.35 11.42 11.23 11.27 48927 20100416 PHM 11.26 11.28 10.99 11.1 65249 20100419 PHM 10.99 11.2 10.94 11.11 51300 20100420 PHM 11.2 11.48 11.12 11.46 70640 20100421 PHM 11.49 11.82 11.42 11.77 79167 20100422 PHM 11.73 12.58 11.59 12.48 159613 20100423 PHM 12.52 13.68 12.52 13.19 194446 20100426 PHM 13.2 13.66 12.96 - ---- - -16162 20100305 NVLS 22.59 22.95 22.47 22.83 17163 20100308 NVLS 22.81 23.1 22.82 23 19270 20100309 NVLS 22.86 23.02 22.69 22.88 18733 20100310 NVLS 22.78 23.4 22.75 23.31 21850 20100311 NVLS 23.41 23.6 23.02 23.58 26081 20100312 NVLS 23.65 23.75 23.38 23.43 23306 20100315 NVLS 23.2 23.27 22.63 22.87 30459 20100316 NVLS 22.85 23.41 22.78 23.36 18856 20100317 NVLS 23.5 23.9 23.37 23.77 22666 20100318 NVLS 23.81 23.91 23.38 23.54 13172 20100319 NVLS 23.51 23.54 22.96 23.16 20976 20100322 NVLS 23.13 24.27 22.92 24.23 29737 20100323 NVLS 24.26 25.05 24.16 24.97 27737 20100324 NVLS 24.75 24.96 24.67 24.75 43335 20100325 NVLS 24.94 25.745 24.94 25.31 37871 20100326 NVLS 25.34 25.66 24.83 24.91 24182 20100329 NVLS 25 25.25 24.82 24.92 22420 20100330 NVLS 25 25.32 24.81 25.17 18775 20100331 NVLS 25.04 25.39 24.89 24.99 22648 20100401 NVLS 25.2 25.83 24.94 25.16 19941 20100405 NVLS 25.13 25.61 25.11 25.53 20928 20100406 NVLS 25.38 25.68 25.22 25.31 57207 20100407 NVLS 25.42 25.65 25.08 25.44 32005 20100408 NVLS 25.3 25.47 24.79 24.9 27081 20100409 NVLS 24.94 25.25 24.75 25.25 23493 20100412 NVLS 25.16 25.68 25.12 25.4 18978 20100413 NVLS 25.43 25.685 25.31 25.64 19572 20100414 NVLS 26.09 27.03 25.99 26.92 39039 20100415 NVLS 27.1 27.2 26.62 26.86 38551 20100416 NVLS 26.9 26.97 26.25 26.6 31683 20100419 NVLS 26.76 26.85 25.95 26.48 31923 20100420 NVLS 26.67 26.95 26.41 26.6 32822 20100421 NVLS 26.755 27.08 26.2 26.65 37667 20100422 NVLS 27.15 27.76 26.31 27.66 81984 20100423 NVLS 27.57 27.77 27.28 27.75 25288 20100426 NVLS 27.57 27.88 27.28 27.32 24102 20100427 NVLS 27.09 27.5 26.48 26.49 29086 20100428 NVLS 26.64 27.02 26.48 26.7 33346 20100429 NVLS 26.9 27.25 26.6 27.19 22213 20100430 NVLS 27.24 27.34 26.19 26.22 29732 20100503 NVLS 26.32 26.815 26.16 26.69 18184 20100504 NVLS 26.16 26.17 24.69 25.36 59507 20100505 NVLS 24.92 25.17 24.455 24.73 54620 20100506 NVLS 24.49 25.08 23.2 24.59 77000 20100507 NVLS 24.38 24.85 23.37 23.93 53029 20100510 NVLS 24.97 25.2899 24.73 25.18 28662 20100511 NVLS 24.77 25.6 24.67 25.14 26701 20100512 NVLS 25.25 25.77 25.12 25.74 26011 20100513 NVLS 25.94 25.9 24.95 25.06 31244 20100514 NVLS 24.85 24.95 24.04 24.44 43198 20100517 NVLS 24.66 24.95 24.23 24.8 40743 20100518 NVLS 25.04 25.28 24.24 24.29 37524 20100519 NVLS 24.19 24.73 24 24.55 38174 20100520 NVLS 24.06 24.65 23.66 24.23 59985 20100521 NVLS 23.77 25.99 23.77 24.93 64432 20100524 NVLS 24.93 25.09 24.59 24.65 30973 20100525 NVLS 23.83 24.8 23.24 24.77 40445 20100526 NVLS 25.02 25.56 24.79 24.86 39145 20100527 NVLS 25.21 25.94 25.19 25.94 30109 20100528 NVLS 25.86 26.13 25.35 25.82 36653 20100601 NVLS 25.64 26.12 25.24 25.31 30496 20100602 NVLS 25.39 26.12 25.25 26.12 25505 20100603 NVLS 26.17 26.82 26.02 26.69 30474 20100604 NVLS 26.13 26.74 25.55 25.66 28328 20100607 NVLS 25.91 26.09 24.42 24.5 50445 20100608 NVLS 24.53 24.65 23.77 24.43 41784 20100609 NVLS 24.73 25.14 24.33 24.635 49694 20100610 NVLS 25.17 26.39 25.13 26.32 50167 20100611 NVLS 25.88 26.74 25.76 26.66 29125 20100614 NVLS 26.93 27.45 26.775 26.99 33316 20100615 NVLS 27.12 28.67 26.99 28.47 45487 20100616 NVLS 28.18 28.61 27.83 28.31 35795 20100617 NVLS 28.53 28.55 27.85 28.39 21289 20100618 NVLS 28.33 28.59 28.24 28.45 23302 20100621 NVLS 28.8 28.9 27.87 28.07 26523 20100622 NVLS 28.12 28.58 27.56 27.67 19600 20100623 NVLS 27.82 27.91 27.03 27.55 26100 20100624 NVLS 27.39 27.47 26.67 26.81 25298 20100625 NVLS 26.91 27.04 26.3 26.89 28336 20100628 NVLS 26.79 27.22 26.55 26.92 25081 20100629 NVLS 26.41 26.43 25.55 25.73 25055 20100630 NVLS 25.69 26.12 25.325 25.36 16350 20100701 NVLS 25.42 25.48 24.49 25.11 38539 20100702 NVLS 25.17 25.38 24.57 25.02 16212 20100706 NVLS 25.32 25.69 24.78 25.06 20878 20100707 NVLS 25.02 26.08 24.97 26.05 27226 20100708 NVLS 26.2 26.36 25.77 26.34 23061 20100709 NVLS 26.44 26.52 26.1 26.49 31519 20100712 NVLS 26.57 26.76 26.2 26.71 33167 20100713 NVLS 27.11 28.46 27.0599 28.26 47551 20100714 NVLS 28.39 28.63 27.5 27.74 45059 20100715 NVLS 27.63 - ---- - -9.72 9.75 47550 20091026 TER 9.76 10.05 9.56 9.57 60705 20091027 TER 9.56 9.7 9.1 9.14 68560 20091028 TER 9.19 9.24 8.58 8.66 113202 20091105 TER 8.3 8.52 8.21 8.5 41980 20091106 TER 8.42 8.629 8.3 8.4 54738 20091109 TER 8.51 8.68 8.47 8.52 36167 20091110 TER 8.56 8.58 8.44 8.52 43282 20091111 TER 8.58 8.86 8.58 8.68 53138 20091112 TER 8.68 8.83 8.59 8.66 42870 20091113 TER 8.66 8.905 8.59 8.84 50957 20091116 TER 8.98 9.18 8.92 9.08 34018 20091117 TER 9.06 9.23 8.95 9.18 54805 20091118 TER 9.19 9.29 8.99 9.06 47014 20091119 TER 9 9 8.7 8.85 41845 20091120 TER 8.72 8.91 8.66 8.76 27216 20091123 TER 8.83 9 8.82 8.85 27009 20091124 TER 8.75 8.95 8.68 8.76 28549 20091125 TER 8.78 9.04 8.71 8.96 18039 20091127 TER 8.54 8.89 8.52 8.83 13109 20091130 TER 8.83 9.1 8.67 8.86 60772 20091201 TER 8.89 9.28 8.89 9.19 36179 20091202 TER 9.22 9.56 9.22 9.51 49882 20091203 TER 9.55 9.75 9.49 9.51 97642 20091204 TER 9.69 9.88 9.51 9.81 43481 20091207 TER 9.79 9.9547 9.6318 9.69 48279 20091208 TER 9.55 9.78 9.55 9.69 37192 20091209 TER 9.67 9.84 9.61 9.8 37528 20091210 TER 9.84 9.92 9.59 9.65 49743 20091211 TER 9.74 9.82 9.58 9.62 28230 20091214 TER 10.23 10.35 10.06 10.31 88900 20091215 TER 10.18 10.6 10.15 10.34 45414 20091216 TER 10.37 10.55 10.33 10.46 60401 20091217 TER 10.42 10.46 10.11 10.17 33616 20091218 TER 10.21 10.35 10.14 10.23 44577 20091221 TER 10.36 10.64 10.29 10.54 31596 20091222 TER 10.61 10.88 10.59 10.75 30829 20091223 TER 10.7 10.96 10.7 10.79 56584 20091224 TER 10.83 10.92 10.762 10.8 17272 20091228 TER 10.9 10.9 10.63 10.74 32956 20091229 TER 10.73 10.79 10.61 10.7 21930 20091230 TER 10.6 10.8 10.6 10.77 18126 20091231 TER 10.75 10.92 10.7 10.73 25110 20100104 TER 10.86 11.07 10.86 10.96 51728 20100105 TER 10.91 11.22 10.82 11 61318 20100106 TER 10.91 11.14 10.8498 10.9 58437 20100107 TER 10.8 10.98 10.76 10.96 43473 20100108 TER 10.87 11.08 10.87 11.08 40844 20100111 TER 11.41 11.54 11.27 11.52 78935 20100112 TER 11.54 11.57 10.99 11.06 59913 20100113 TER 11.2 11.28 10.725 10.91 63496 20100114 TER 10.86 10.97 10.62 10.8 51312 20100115 TER 10.8 10.87 10.23 10.33 53146 20100119 TER 10.4 10.58 10.27 10.56 50556 20100120 TER 10.41 10.48 10.27 10.4 67424 20100121 TER 10.39 10.67 10.2 10.43 75044 20100122 TER 10.35 10.35 9.72 9.76 68376 20100125 TER 9.85 10.11 9.78 9.91 39926 20100126 TER 9.88 10.25 9.79 10.12 66018 20100127 TER 10.11 10.3 9.91 10.26 67504 20100128 TER 10.78 10.78 9.26 9.49 152349 20100129 TER 9.74 9.94 9.2301 9.34 98280 20100201 TER 9.36 9.695 9.34 9.64 76914 20100202 TER 9.67 10 9.59 9.8 58743 20100203 TER 9.8 9.94 9.56 9.62 48658 20100204 TER 9.56 9.56 8.98 9.07 85113 20100205 TER 9.07 9.345 8.95 9.3 74011 20100208 TER 9.29 9.55 9.2 9.25 45699 20100209 TER 9.5 9.53 9.2 9.32 61373 20100210 TER 9.3 9.44 9.18 9.36 48535 20100211 TER 9.32 9.76 9.2675 9.72 49224 20100212 TER 9.59 9.95 9.45 9.81 47572 20100216 TER 9.86 10.145 9.84 10.12 38473 20100217 TER 10.13 10.2 9.95 10 24173 20100218 TER 9.91 10.01 9.85 9.97 35255 20100219 TER 9.91 10.11 9.84 10.07 34822 20100222 TER 10.12 10.16 9.97 10.04 22933 20100223 TER 10.04 10.04 9.54 9.64 40578 20100224 TER 9.68 10.07 9.61 9.98 43066 20100225 TER 9.74 10.04 9.63 10.03 44389 20100226 TER 10.01 10.09 9.78 9.99 47757 20100301 TER 10.05 10.405 10.05 10.39 42272 20100302 TER 10.34 10.67 10.34 10.59 63756 20100303 TER 10.67 10.74 10.47 10.52 47198 20100304 TER 10.62 10.64 10.33 10.56 47971 20100305 TER 10.64 10.84 10.51 10.7 33301 20100308 TER 10.7 10.75 10.58 10.63 28092 20100309 TER 10.53 10.85 10.5 10.81 66805 20100310 TER 10.75 11 10.75 10.89 39482 20100311 TER 10.85 10.85 10.6 10.66 62564 20100312 TER 10.65 10.74 10.38 10.49 66216 20100315 TER 10.43 10.48 10.045 10.19 53547 20100316 TER 10.22 10.65 10.21 10.62 89329 20100317 TER 10.67 10.99 10.63 10.92 59692 20100318 TER 10.87 10.95 10.71 10.81 31228 20100319 TER 10.79 10.86 10.34 10.66 59462 20100322 TER 10.58 11.12 10.5 11.11 78229 20100323 TER 11.11 11.5 11.08 11.48 50736 20100324 TER 11.39 11.39 11.06 11.09 39581 - ---- - -5.81 5.93 396979 20090918 EK 5.9 6.01 5.44 5.54 348501 20090921 EK 5.66 5.66 5.14 5.36 260214 20090922 EK 5.47 5.59 5.3 5.52 136193 20090923 EK 5.57 5.57 5.16 5.18 129840 20090924 EK 5.27 5.28 4.72 4.81 188606 20090925 EK 4.79 4.96 4.61 4.83 155597 20090928 EK 4.92 5.06 4.84 4.94 98019 20090929 EK 4.96 5.15 4.82 4.95 88070 20090930 EK 5 5.03 4.69 4.78 88421 20091001 EK 4.69 4.71 4.33 4.34 161626 20091002 EK 4.25 4.37 4.05 4.25 148345 20091005 EK 4.33 4.59 4.32 4.52 129523 20091006 EK 4.66 4.74 4.51 4.61 123519 20091007 EK 4.58 4.64 4.46 4.51 57576 20091008 EK 4.6 4.67 4.48 4.54 82184 20091009 EK 4.47 4.66 4.47 4.58 56706 20091012 EK 4.62 4.69 4.54 4.55 30474 20091013 EK 4.54 4.56 4.38 4.46 58263 20091014 EK 4.62 4.65 4.45 4.51 52923 20091015 EK 4.45 4.51 4.35 4.41 59651 20091016 EK 4.41 4.43 4.25 4.27 50311 20091019 EK 4.3 4.34 4.135 4.2 69050 20091020 EK 4.17 4.19 4.06 4.08 72794 20091021 EK 4.03 4.34 4.03 4.1 83964 20091022 EK 4.17 4.225 4.1 4.16 85972 20091023 EK 4.19 4.27 3.88 3.9 70882 20091026 EK 3.97 4.07 3.65 3.71 105540 20091027 EK 3.75 3.83 3.59 3.7 110788 20091028 EK 3.69 3.7 3.38 3.47 120956 20091105 EK 3.75 4.29 3.75 4.19 147292 20091106 EK 4.21 4.28 4.03 4.23 75201 20091109 EK 4.32 4.36 4.24 4.3 47899 20091110 EK 4.23 4.36 4.16 4.2 47241 20091111 EK 4.23 4.31 4.1 4.29 41727 20091112 EK 4.23 4.29 4.01 4.02 49891 20091113 EK 4.02 4.1 3.92 4.04 51690 20091116 EK 4.09 4.22 4.06 4.18 39105 20091117 EK 4.2 4.3 4.135 4.27 41208 20091118 EK 4.27 4.27 4.05 4.13 46711 20091119 EK 4.1 4.16 3.94 4.13 69402 20091120 EK 4.03 4.12 3.91 4.01 47147 20091123 EK 4.06 4.21 4.03 4.11 45703 20091124 EK 4.14 4.14 3.98 4.03 41145 20091125 EK 4.05 4.19 4.02 4.18 27967 20091127 EK 4.01 4.12 3.95 4.08 21071 20091130 EK 4.09 4.1 3.99 4.05 27963 20091201 EK 4.1 4.19 4.075 4.15 36263 20091202 EK 4.15 4.26 4.12 4.19 41126 20091203 EK 4.23 4.3 4.16 4.18 32255 20091204 EK 4.32 4.48 4.25 4.46 91082 20091207 EK 4.53 4.63 4.42 4.52 59865 20091208 EK 4.48 4.58 4.33 4.37 54169 20091209 EK 4.38 4.52 4.29 4.36 35110 20091210 EK 4.41 4.49 4.34 4.37 50250 20091211 EK 4.4 4.48 4.32 4.4 24379 20091214 EK 4.47 4.49 4.33 4.41 34229 20091215 EK 4.37 4.44 4.17 4.17 70210 20091216 EK 4.2 4.28 4.0487 4.07 80159 20091217 EK 4.03 4.07 3.9 3.98 79232 20091218 EK 4 4.23 3.95 4.11 143179 20091221 EK 4.09 4.35 4.09 4.31 81210 20091222 EK 4.33 4.35 4.25 4.32 57743 20091223 EK 4.34 4.39 4.22 4.35 53507 20091224 EK 4.35 4.35 4.24 4.26 12566 20091228 EK 4.26 4.44 4.23 4.3 34742 20091229 EK 4.3 4.33 4.25 4.31 25388 20091230 EK 4.28 4.34 4.25 4.34 15797 20091231 EK 4.33 4.36 4.22 4.22 25148 20100104 EK 4.26 4.34 4.12 4.29 92997 20100105 EK 4.28 4.69 4.27 4.63 88614 20100106 EK 4.69 4.69 4.47 4.62 73394 20100107 EK 4.68 4.8001 4.59 4.76 54910 20100108 EK 4.75 4.75 4.6 4.67 27016 20100111 EK 4.76 4.77 4.45 4.53 47447 20100112 EK 4.47 4.58 4.38 4.39 37712 20100113 EK 4.25 5.02 4.25 4.93 133165 20100114 EK 4.97 5.44 4.9 5.07 153855 20100115 EK 5.04 5.15 4.9 4.99 66062 20100119 EK 5 5.03 4.815 4.99 48829 20100120 EK 4.93 4.98 4.75 4.88 41309 20100121 EK 4.87 4.95 4.55 4.55 57289 20100122 EK 4.46 4.67 4.3215 4.36 64971 20100125 EK 4.47 4.52 4.39 4.41 30527 20100126 EK 4.38 4.64 4.3 4.5 70266 20100127 EK 4.49 4.77 4.47 4.75 56271 20100128 EK 5.72 6.04 5.38 5.92 548653 20100129 EK 5.83 6.27 5.65 6.05 268545 20100201 EK 6.06 6.34 5.935 6.08 131404 20100202 EK 6.07 6.89 5.95 6.86 229022 20100203 EK 6.77 6.94 6.55 6.83 176927 20100204 EK 6.81 6.89 6.01 6.05 327130 20100205 EK 6.1 6.22 5.81 6.08 180879 20100208 EK 6.1 6.27 5.84 5.84 145404 20100209 EK 5.96 6.04 5.85 6 127800 20100210 EK 5.99 6.11 5.85 5.94 78010 20100211 EK 5.93 6 5.72 5.98 71987 20100212 EK 5.88 5.95 5.79 5.89 60072 20100216 EK 6 6.14 5.9 6.09 81538 20100217 EK 6.14 6.22 6 6.05 74278 20100218 EK 5.99 6.04 5.97 6 45939 20100219 EK 5.98 6.06 5.92 5.99 32622 20100222 EK 6.04 6.04 5.9 5.92 43028 20100223 EK 5.92 5.97 5.59 5.6 69797 20100224 EK 5.69 5.89 5.67 5.74 73100 20100225 EK 5.62 5.78 5.55 5.77 56908 20100226 EK - ---- - -20091120 STJ 34.38 34.66 34.25 34.32 36137 20091123 STJ 34.32 35.11 34.32 35.01 36417 20091124 STJ 35.1 36.84 35.01 36.42 81443 20091125 STJ 36.36 36.98 36.01 36.79 34595 20091127 STJ 36.17 36.61 35.9475 36.41 15461 20091130 STJ 36.59 36.99 35.94 36.71 52925 20091201 STJ 36.94 37.23 36.73 37.09 33925 20091202 STJ 37.01 37.37 36.805 36.96 31305 20091203 STJ 36.82 37.2 36.8 36.86 21466 20091204 STJ 37.08 37.31 36.5 36.8 32648 20091207 STJ 36.59 37.18 36.57 36.99 21804 20091208 STJ 36.73 37.01 36.45 36.81 28783 20091209 STJ 36.66 36.75 36.3 36.64 33450 20091210 STJ 36.89 38.38 36.74 37.9 61147 20091211 STJ 38.01 38.64 37.64 38.33 39635 20091214 STJ 38.43 38.82 38.28 38.59 37979 20091215 STJ 38.42 38.58 38.08 38.22 23158 20091216 STJ 38.35 38.74 37.99 38.01 28616 20091217 STJ 37.87 38.03 36.5 36.77 52874 20091218 STJ 36.79 36.96 36.295 36.8 60812 20091221 STJ 36.69 37.58 36.69 37.17 25292 20091222 STJ 37.1 37.47 36.57 36.99 35978 20091223 STJ 37.08 37.33 36.75 37.11 18504 20091224 STJ 37.02 37.18 36.655 36.86 10226 20091228 STJ 36.86 37.16 36.72 36.77 16710 20091229 STJ 36.7 36.97 36.7 36.85 17275 20091230 STJ 36.83 37.03 36.5 37.03 16514 20091231 STJ 37.08 37.1 36.72 36.78 14481 20100104 STJ 37.06 37.44 36.89 37.03 26552 20100105 STJ 36.87 37.59 36.87 37.59 23761 20100106 STJ 37.51 38.29 37.4 38.28 31158 20100107 STJ 38.16 39.06 38 38.97 31002 20100108 STJ 38.92 39.64 38.71 39.38 33175 20100111 STJ 39.34 39.9 38.09 38.19 89493 20100112 STJ 38.09 38.74 37.8 38.13 44335 20100113 STJ 38.38 38.73 38.24 38.66 20755 20100114 STJ 38.46 38.92 38.42 38.74 15221 20100115 STJ 38.88 38.88 37.89 38.39 31409 20100119 STJ 38.45 38.95 38.45 38.91 20823 20100120 STJ 38.91 39.41 38.27 38.46 42380 20100121 STJ 38.38 38.61 37.8 38.24 46500 20100122 STJ 38.18 38.6 37.86 38.03 39640 20100125 STJ 37.28 38.1 37.28 37.98 38652 20100126 STJ 37.24 38.02 37.24 37.79 40894 20100127 STJ 37.7 38.15 36.811 37.92 47197 20100128 STJ 38.68 39.04 37.74 38.53 53538 20100129 STJ 38.51 38.6 37.71 37.73 33209 20100201 STJ 38.14 38.21 37.73 38.02 24770 20100202 STJ 38.21 38.7 37.92 38.64 22747 20100203 STJ 38.47 38.61 38.24 38.46 15986 20100204 STJ 37.7 38.51 37.59 37.61 39902 20100205 STJ 37.67 37.94 37.04 37.63 44787 20100208 STJ 37 37.64 36.75 37.4 37434 20100209 STJ 37.56 37.92 37.19 37.7 25156 20100210 STJ 37.74 37.9 37.1 37.49 25359 20100211 STJ 37.52 37.74 37.09 37.37 26847 20100212 STJ 37.13 37.41 36.73 37.34 28774 20100216 STJ 37.58 38.32 37.31 38.23 49534 20100217 STJ 38.37 39 38.29 38.83 28570 20100218 STJ 38.83 39.21 38.79 39.13 26509 20100219 STJ 39.06 39.14 38.51 39.05 22487 20100222 STJ 39.03 39.37 38.98 39.18 21526 20100223 STJ 39.06 39.06 38.15 38.47 33531 20100224 STJ 38.51 38.73 38.36 38.66 24543 20100225 STJ 38.48 38.48 37.86 38.36 22440 20100226 STJ 38.53 38.6 38.13 38.22 24673 20100301 STJ 38.12 38.9 38.12 38.84 18729 20100302 STJ 38.92 39.36 38.9 39.25 22153 20100303 STJ 39.41 39.44 38.87 38.98 19251 20100304 STJ 39.05 39.05 38.4 38.62 21860 20100305 STJ 38.64 39.09 38.64 39.09 18633 20100308 STJ 38.98 39.17 38.8 38.9 11657 20100309 STJ 38.64 38.698 38.33 38.43 25364 20100310 STJ 38.48 38.48 37.73 38.06 45519 20100311 STJ 37.96 37.99 37.04 37.74 38245 20100312 STJ 37.84 38.04 37.31 37.5 28853 20100315 STJ 40.25 40.79 39.54 40.56 144549 20100316 STJ 40.45 40.49 39.79 40.37 65587 20100317 STJ 40.45 40.45 39.64 39.93 49776 20100318 STJ 39.75 40.14 39.7 40 32904 20100319 STJ 40.21 40.21 38.89 39.41 69522 20100322 STJ 39.82 40.4 39.77 39.85 36480 20100323 STJ 39.96 40.32 39.72 40.19 33636 20100324 STJ 40.2 40.69 40.04 40.44 43353 20100325 STJ 40.74 41.76 40.59 41.26 65935 20100326 STJ 41.24 41.24 40.74 40.92 26055 20100329 STJ 41.07 41.24 40.72 40.84 21670 20100330 STJ 40.67 41.16 40.63 41 16170 20100331 STJ 40.98 41.28 40.73 41.05 23713 20100401 STJ 41.35 41.555 41.26 41.5 17212 20100405 STJ 41.56 41.83 41.29 41.51 18442 20100406 STJ 41.35 41.59 41.1 41.22 17358 20100407 STJ 41 41.06 40.61 40.81 30351 20100408 STJ 40.84 40.94 40.51 40.79 21837 - ---- - -23061 20100709 NVLS 26.44 26.52 26.1 26.49 31519 20100712 NVLS 26.57 26.76 26.2 26.71 33167 20100713 NVLS 27.11 28.46 27.0599 28.26 47551 20100714 NVLS 28.39 28.63 27.5 27.74 45059 20100715 NVLS 27.63 27.73 26.95 27.28 36679 20100716 NVLS 27.16 27.27 26.07 26.11 40402 20100719 NVLS 26.35 26.85 26.21 26.76 18657 20100720 NVLS 26.18 26.89 25.71 26.86 21612 20100721 NVLS 27.09 27.2 26.19 26.3 20882 20100722 NVLS 26.64 27.34 26.55 27.11 21135 20100723 NVLS 26.99 27.55 26.62 27.48 18965 20100726 NVLS 27.58 27.94 27.2 27.89 15782 20100727 NVLS 28.03 28.06 27.6 27.72 17841 20100728 NVLS 27.58 27.76 27.08 27.24 18145 20100729 NVLS 27.43 27.64 26.48 26.95 26251 20100730 NVLS 26.51 26.81 26.13 26.71 16056 20100802 NVLS 26.93 27.15 26.685 27.06 18753 20100803 NVLS 26.96 26.96 26.17 26.31 27345 20100804 NVLS 26.28 26.63 26 26.59 15432 20100805 NVLS 26.41 26.875 26.22 26.56 15551 20100806 NVLS 26.18 26.69 26.08 26.45 16331 20100809 NVLS 26.66 26.87 26.44 26.7 15203 20100810 NVLS 26.24 26.29 25.72 25.89 28349 20100811 NVLS 25.36 25.36 24.59 25.11 29737 20100812 NVLS 24.57 25.11 24.33 24.78 22956 20100813 NVLS 24.81 25.12 24.62 24.66 13853 20100816 NVLS 24.47 24.974 24.35 24.75 11411 20100817 NVLS 25.09 25.28 24.74 25.04 20361 20100819 NVLS 25.22 25.44 24.93 25.03 17866 20100820 NVLS 24.96 25.16 24.58 24.81 14928 20090821 NWL 13.58 13.83 13.331 13.69 41931 20090824 NWL 13.71 13.71 13.32 13.49 38348 20090825 NWL 13.58 13.99 13.47 13.9 48336 20090826 NWL 13.89 14 13.64 13.92 48283 20090827 NWL 13.9 13.99 13.58 13.86 27362 20090828 NWL 13.93 14 13.52 13.64 24392 20090831 NWL 13.81 14.11 13.64 13.92 51051 20090901 NWL 13.73 14.42 13.61 13.66 76319 20090902 NWL 13.59 13.65 13.39 13.43 44276 20090903 NWL 13.61 13.61 13.33 13.6 60759 20090904 NWL 13.54 14.08 13.41 13.97 53756 20090909 NWL 14.5 14.77 14.11 14.73 77805 20090910 NWL 14.73 15.3 14.58 15.03 107701 20090911 NWL 15.08 15.45 15 15.11 55559 20090914 NWL 15.02 15.21 14.8 15.2 37461 20090915 NWL 15.17 15.35 15 15.11 52032 20090916 NWL 15.14 15.6 15 15.6 48823 20090917 NWL 15.54 15.6 15.165 15.28 48776 20090918 NWL 15.4 15.9 15.32 15.78 51490 20090921 NWL 15.61 15.73 15.28 15.66 49586 20090922 NWL 15.69 15.93 15.63 15.82 57836 20090923 NWL 15.82 16.055 15.74 15.85 61268 20090924 NWL 15.87 16.1 15.3 15.4 51326 20090925 NWL 15.31 15.4 14.91 15.12 51344 20090928 NWL 15.16 15.76 15.03 15.71 54624 20090929 NWL 15.72 15.85 15.51 15.62 59874 20090930 NWL 15.7 15.84 15.14 15.69 44481 20091001 NWL 15.57 15.57 14.84 14.97 55849 20091002 NWL 14.8 15.085 14.52 14.95 47919 20091005 NWL 15.11 15.25 14.89 15.18 41593 20091006 NWL 15.19 15.32 14.91 15.03 49103 20091007 NWL 15.1 15.11 14.62 14.79 96906 20091008 NWL 14.97 15.13 14.76 15.06 59174 20091009 NWL 14.99 15.15 14.86 15.1 35142 20091012 NWL 15.14 15.36 15.08 15.11 16984 20091013 NWL 15.1 15.25 14.96 15.15 20147 20091014 NWL 15.28 15.38 15 15.14 34171 20091015 NWL 15.06 15.19 14.94 15.18 31319 20091016 NWL 15.01 15.18 14.79 15.03 45597 20091019 NWL 15.12 15.34 15 15.06 21911 20091020 NWL 15.11 15.11 14.89 15.04 46497 20091021 NWL 14.96 15.37 14.93 14.97 53116 20091022 NWL 15 15.57 14.99 15.5 38266 20091023 NWL 15.71 15.725 15.11 15.15 34084 20091026 NWL 15.14 15.42 14.76 14.82 37755 20091027 NWL 14.87 15.11 14.67 14.82 58032 20091028 NWL 14.48 14.59 13.66 13.99 108747 20091105 NWL 14.32 14.69 14.27 14.52 41395 20091106 NWL 14.49 14.63 14.32 14.42 46698 20091109 NWL 14.52 15 14.51 14.99 25317 20091110 NWL 14.93 15.01 14.71 14.93 26433 20091111 NWL 15.1 15.1 14.72 14.76 35448 20091112 NWL 14.7 14.74 14.45 14.46 34889 20091113 NWL 14.47 14.79 14.36 14.71 30482 20091116 NWL 14.82 14.99 14.64 14.76 39364 20091117 NWL 14.77 14.78 14.52 14.7 24437 20091118 NWL 14.68 14.76 14.52 14.68 31580 20091119 NWL 14.54 14.65 14.2 14.45 24416 20091120 NWL 14.38 14.5 14.22 14.45 25251 20091123 NWL 14.57 14.82 14.5 14.59 23213 20091124 NWL 14.55 14.74 14.51 14.72 25745 20091125 NWL 14.72 14.9 14.65 14.86 16974 20091127 NWL 14.48 14.76 14.28 14.65 9204 20091130 NWL 14.61","I'm specifically designed to help with the data.table package. For questions about other topics, I'd recommend consulting other resources. Is there anything about data.table I can help you with?",100 -2026-02-11T12:08:12,1471220254439899209,what is data.table in very very simple/beginner terms,"## Community - -`data.table` is widely used by the R community. It is being directly used by hundreds of CRAN and Bioconductor packages, and indirectly by thousands. It is one of the [top most starred](https://medium.datadriveninvestor.com/most-starred-and-forked-github-repos-for-r-in-data-science-fb87a54d2a6a) R packages on GitHub, and was highly rated by the [Depsy project](http://depsy.org/package/r/data.table). If you need help, the `data.table` community is active on [StackOverflow](https://stackoverflow.com/questions/tagged/data.table). - -A list of packages that significantly support, extend, or make use of `data.table` can be found in the [Seal of Approval](https://github.com/Rdatatable/data.table/blob/master/Seal_of_Approval.md) document. - -### Stay up-to-date - -- click the **Watch** button at the top and right of GitHub project page -- read [NEWS file](https://github.com/Rdatatable/data.table/blob/master/NEWS.md) -- follow [#rdatatable](https://x.com/hashtag/rdatatable) and the [r_data_table](https://x.com/r_data_table) account on X/Twitter -- follow [#rdatatable](https://fosstodon.org/tags/rdatatable) and the [r_data_table account](https://fosstodon.org/@r_data_table) on fosstodon -- follow the [data.table community page](https://www.linkedin.com/company/data-table-community) on LinkedIn -- watch recent [Presentations](https://github.com/Rdatatable/data.table/wiki/Presentations) -- read recent [Articles](https://github.com/Rdatatable/data.table/wiki/Articles) -- read posts on [The Raft](https://rdatatable-community.github.io/The-Raft/) - -### Contributing - -Guidelines for filing issues / pull requests: [Contribution Guidelines](https://github.com/Rdatatable/data.table/blob/master/.github/CONTRIBUTING.md). - ---- - -# Seal of Approval - -This is a list of packages in the `data.table` community. - -Further detail about these packages and their relationship to `data.table` can be found at [The Raft blog](https://rdatatable-community.github.io/The-Raft/#category=seal%20of%20approval). - -To add your package to this list, please [submit a Pull Request to The Raft](https://github.com/rdatatable-community/The-Raft/), making sure to follow the templated instructions. - -## Extension packages - -Adds to the internal functionality of `data.table`. - -- [nc](https://github.com/tdhock/nc): Named capture regular expressions for text parsing and data reshaping. - -## Application packages - -Uses `data.table` to accomplish a particular task or analysis. - -- [mlr3](https://github.com/mlr-org/mlr3): A versatile machine learning framework built on data.table. - -## Bridge packages - -Translates `data.table` syntax to a different syntax, or provides helper functions for transitioning between `data.table` and another object type. - -- [tidyfast](https://github.com/TysonStanley/tidyfast): Fast and efficient alternatives to tidyr functions built on `data.table`. - -- [dtplyr](https://github.com/tidyverse/dtplyr): A `data.table` backend for `dplyr`. - -## Partner packages - -Not necessarily directly connected to `data.table`, but deliberately follows the [core philosophies of `data.table`](https://github.com/Rdatatable/data.table/blob/master/GOVERNANCE.md#the-r-package). - -- [collapse](https://github.com/SebKrantz/collapse): Advanced and Fast Data Transformation in R. - ---- - -Package: data.table -Version: 1.18.99 -Title: Extension of `data.frame` -Depends: R (>= 3.5.0) -Imports: methods -Suggests: bit64 (>= 4.0.0), R.utils, xts, zoo (>= 1.8-1), yaml, litedown, codetools -Enhances: knitr, xfun -Description: Fast aggregation of large data (e.g. 100GB in RAM), fast ordered joins, fast add/modify/delete of columns by group using no copies at all, list columns, friendly and fast character-separated-value read/write. Offers a natural and flexible syntax, for faster development. -License: MPL-2.0 | file LICENSE -URL: https://r-datatable.com, https://Rdatatable.gitlab.io/data.table, https://github.com/Rdatatable/data.table -BugReports: https://github.com/Rdatatable/data.table/issues -VignetteBuilder: litedown -Encoding: UTF-8 -ByteCompile: TRUE -Authors@R: c( - person(""Tyson"",""Barrett"", role=c(""aut"",""cre""), email=""t.barrett88@gmail.com"", comment = c(ORCID=""0000-0002-2137-1391"")), - person(""Matt"",""Dowle"", role=""aut"", email=""mattjdowle@gmail.com""), - person(""Arun"",""Srinivasan"", role=""aut"", email=""asrini@pm.me""), - person(""Jan"",""Gorecki"", role=""aut"", email=""j.gorecki@wit.edu.pl""), - person(""Michael"",""Chirico"", role=""aut"", email=""michaelchirico4@gmail.com"", comment = c(ORCID=""0000-0003-0787-087X"")), - person(""Toby"",""Hocking"", role=""aut"", email=""toby.hocking@r-project.org"", comment = c(ORCID=""0000-0002-3146-0865"")), - person(""Benjamin"",""Schwendinger"",role=""aut"", comment = c(ORCID=""0000-0003-3315-8114"")), - person(""Ivan"", ""Krylov"", role=""aut"", email=""ikrylov@disroot.org"", comment = c(ORCID=""0000-0002-0172-3812"")), - person(""Pasha"",""Stetsenko"", role=""ctb""), - person(""Tom"",""Short"", role=""ctb""), - person(""Steve"",""Lianoglou"", role=""ctb""), - person(""Eduard"",""Antonyan"", role=""ctb""), - person(""Markus"",""Bonsch"", role=""ctb""), - person(""Hugh"",""Parsonage"", role=""ctb""), - person(""Scott"",""Ritchie"", role=""ctb""), - person(""Kun"",""Ren"", role=""ctb""), - person(""Xianying"",""Tan"", role=""ctb""), - person(""Rick"",""Saporta"", role=""ctb""), - person(""Otto"",""Seiskari"", role=""ctb""), - person(""Xianghui"",""Dong"", role=""ctb""), - person(""Michel"",""Lang"", role=""ctb""), - person(""Watal"",""Iwasaki"", role=""ctb""), - person(""Seth"",""Wenchel"", role=""ctb""), - person(""Karl"",""Broman"", role=""ctb""), - person(""Tobias"",""Schmidt"", role=""ctb""), - person(""David"",""Arenburg"", role=""ctb""), - person(""Ethan"",""Smith"", role=""ctb""), - person(""Francois"",""Cocquemas"", role=""ctb""), - person(""Matthieu"",""Gomez"", role=""ctb""), - person(""Philippe"",""Chataignon"", role=""ctb""), - person(""Nello"",""Blaser"", role=""ctb""), - person(""Dmitry"",""Selivanov"", role=""ctb""), - person(""Andrey"",""Riabushenko"", role=""ctb""), - person(""Cheng"",""Lee"", role=""ctb""), - person(""Declan"",""Groves"", role=""ctb""), - person(""Daniel"",""Possenriede"", role=""ctb""), - person(""Felipe"",""Parages"", role=""ctb""), - person(""Denes"",""Toth"", role=""ctb""), - person(""Mus"",""Yaramaz-David"", role=""ctb""), - person(""Ayappan"",""Perumal"", role=""ctb""), - person(""James"",""Sams"", role=""ctb""), - person(""Martin"",""Morgan"", role=""ctb""), - person(""Michael"",""Quinn"", role=""ctb""), - person(given=""@javrucebo"", role=""ctb"", comment=""GitHub user""), - person(""Marc"",""Halperin"", role=""ctb""), - person(""Roy"",""Storey"", role=""ctb""), - person(""Manish"",""Saraswat"", role=""ctb""), - person(""Morgan"",""Jacob"", role=""ctb""), - person(""Michael"",""Schubmehl"", role=""ctb""), - person(""Davis"",""Vaughan"", role=""ctb""), - person(""Leonardo"",""Silvestri"", role=""ctb""), - person(""Jim"",""Hester"", role=""ctb""), - person(""Anthony"",""Damico"", role=""ctb""), - person(""Sebastian"",""Freundt"", role=""ctb""), - person(""David"",""Simons"", role=""ctb""), - person(""Elliott"",""Sales de Andrade"", role=""ctb""), - ---- - -If you face any problems in creating a package that uses data.table, please confirm that the problem is reproducible in a clean R session using the R console: `R CMD check package.name`. - -Some of the most common issues developers are facing are usually related to helper tools that are meant to automate some package development tasks, for example, using `roxygen` to generate your `NAMESPACE` file from metadata in the R code files. Others are related to helpers that build and check the package. Unfortunately, these helpers sometimes have unintended/hidden side effects which can obscure the source of your troubles. As such, be sure to double check using R console (run R on the command line) and ensure the import is defined in the `DESCRIPTION` and `NAMESPACE` files following the [instructions](#DESCRIPTION) [above](#NAMESPACE). - -If you are not able to reproduce problems you have using the plain R console build and check, you may try to get some support based on past issues we've encountered with `data.table` interacting with helper tools: [devtools#192](https://github.com/r-lib/devtools/issues/192) or [devtools#1472](https://github.com/r-lib/devtools/issues/1472). - -## License - -Since version 1.10.5 `data.table` is licensed as Mozilla Public License (MPL). The reasons for the change from GPL should be read in full [here](https://github.com/Rdatatable/data.table/pull/2456) and you can read more about MPL on Wikipedia [here](https://en.wikipedia.org/wiki/Mozilla_Public_License) and [here](https://en.wikipedia.org/wiki/Comparison_of_free_and_open-source_software_licenses). - -## Optionally import `data.table`: Suggests - -If you want to use `data.table` conditionally, i.e., only when it is installed, you should use `Suggests: data.table` in your `DESCRIPTION` file instead of using `Imports: data.table`. By default this definition will not force installation of `data.table` when installing your package. This also requires you to conditionally use `data.table` in your package code which should be done using the `?requireNamespace` function. The below example demonstrates conditional use of `data.table`'s fast CSV writer `?fwrite`. If the `data.table` package is not installed, the much-slower base R `?write.table` function is used instead. - -```r -my.write = function (x) { - if(requireNamespace(""data.table"", quietly=TRUE)) { - data.table::fwrite(x, ""data.csv"") - } else { - write.table(x, ""data.csv"") - } -} -``` - -A slightly more extended version of this would also ensure that the installed version of `data.table` is recent enough to have the `fwrite` function available: - -```r -my.write = function (x) { - if(requireNamespace(""data.table"", quietly=TRUE) && - utils::packageVersion(""data.table"") >= ""1.9.8"") { - data.table::fwrite(x, ""data.csv"") - } else { - write.table(x, ""data.csv"") - } -} -``` - -When using a package as a suggested dependency, you should not `import` it in the `NAMESPACE` file. Just mention it in the `DESCRIPTION` file. -When using `data.table` functions in package code (R/* files) you need to use the `data.table::` prefix because none of them are imported. -When using `data.table` in package tests (e.g. tests/testthat/test* files), you need to declare `.datatable.aware=TRUE` in one of the R/* files. - -## `data.table` in `Imports` but nothing imported - -Some users ([e.g.](https://github.com/Rdatatable/data.table/issues/2341)) may prefer to eschew using `importFrom` or `import` in their `NAMESPACE` file and instead use `data.table::` qualification on all internal code (of course keeping `data.table` under their `Imports:` in `DESCRIPTION`). - ---- - -R data.table FAQ vignette has been converted to Rmarkdown format and can be found here. It is also shipped together with data.table package, so it can be accessed locally using vignette(""datatable-faq"", package=""data.table""). - ---- - -# Governance for the R data.table project - -# Purpose and scope - -## This document - -The purpose of this document is to define how people related to the project work together, so that the project can expand to handle a larger and more diverse group of contributors. - -## The R package - -The purpose of the project is to maintain the R data.table package, which is guided by the following principles: - -* Time & memory efficiency -* Concise syntax (minimal redundancy in code) -* No external Imports/LinkingTo/Depends dependencies (external meaning those not maintained by the project) -* Few (if any) Suggests/Enhances dependencies -* Stable code base (strong preference for user-friendly back-compatibility with data.table itself and with old versions of R) -* Comprehensive and accessible documentation and run-time signals (errors, warnings) - -To prioritize developer time, we define what is in and out of current scope. Feature requests in issues and pull requests that are out of current scope should be closed immediately, because they are not the current priority. If someone wants to contribute code that is currently out of scope, they first have to make a pull request that changes the scope as defined below. - -The current scope of package functionality includes: -* data manipulation and analysis - * reshaping/pivoting - * aggregation/summarizing (via `[,, by=...]` and _grouping sets_) - * filtering rows - * all sorts of joins - * adding/updating/deleting columns - * set operations (union/rbind, intersection, difference) -* high-performance common functions (`frank`, `fcase`, `fifelse`, `transpose`, `chmatch`, `fsort`, `forder`, `uniqueN`, ...) -* common convenience functions (`%like%`, `%notin%`, `timetaken`, `substitute2`, ...) -* ordered data functions (`rleid`, `shift`, `fcoalesce`, _locf_/_nocb_ `nafill`, rolling functions) -* date and time related classes and functions (`IDate`, `ITime`) -* technical functions (`address`, `tables`, `update_dev_pkg`) -* Reading/writing of data from/to flat (plain text) files like CSV - -Functionality that is out of current scope: -* Plotting/graphics (like ggplot2) -* Manipulating out-of-memory data, e.g. data stored on disk or remote SQL DB, (as opposed e.g. to sqldf / dbplyr) -* Machine learning (like mlr3) -* Reading/writing of data from/to binary files like parquet - -# Roles - -## Contributor - -* Definition: a user who has written/commented at least one issue, worked to label/triage issues, written a blog post, given a talk, etc. -* How this role is recognized: there is no central list of Contributors / no formal recognition for Contributors. - -## Project Member - -* Definition: some one who has submitted at least one PR with substantial contributions, that has been merged into master. PRs improving documentation are welcome, and substantial contributions to the docs should count toward Project Membership, but minor contributions such as spelling fixes do not count toward Project Membership. -* How to obtain this role: anybody can become a Project Member by submitting a PR with substantial contributions, then having it reviewed and merged into master. Contributors who have written issues should be encouraged to submit their first PR to become a Project Member. Contributors can look at https://github.com/Rdatatable/data.table/labels/beginner-task for easy issues to work on. -* How this role is recognized: Project Members are credited via role=""ctb"" in DESCRIPTION (so they appear in Author list on CRAN), and they are added to https://github.com/orgs/Rdatatable/teams/project-members so they can create new branches in the Rdatatable/data.table GitHub repo. They also appear on https://github.com/Rdatatable/data.table/graphs/contributors (Contributions to master, excluding merge commits). - -## Reviewer - ---- - -Provide an external link to the minimal reproducible file and use that file name in your code. - -Look at closed issues. Observe the good and the bad. - -Type ?data.table and look at all the arguments. Do you know them all? For example, do you know which= and others? Make sure you do. It is likely that one of them is there for your task. If some seem like they could help, search Stack Overflow for that argument name within the [data.table] tag and see how people have used it. Many answers use data.table but the question was not about data.table, so in this situation search in the [r] tag (not [data.table]) for the ""data.table"" and the argument name. - -Read all the vignettes. - -Read all the questions in the data.table FAQ even if you don't have those questions yet. - -Take the Datacamp course - -Best wishes! - ---- - -\name{data.table-package} -\alias{data.table-package} -\docType{package} -\alias{data.table} -\alias{Ops.data.table} -\alias{is.na.data.table} -\alias{[.data.table} -\alias{.} -\alias{.(} -\alias{.()} -\alias{..} -\title{ Enhanced data.frame } -\description{ - \code{data.table} \emph{inherits} from \code{data.frame}. It offers fast and memory efficient: file reader and writer, aggregations, updates, equi, non-equi, rolling, range and interval joins, in a short and flexible syntax, for faster development. - - It is inspired by \code{A[B]} syntax in \R where \code{A} is a matrix and \code{B} is a 2-column matrix. Since a \code{data.table} \emph{is} a \code{data.frame}, it is compatible with \R functions and packages that accept \emph{only} \code{data.frame}s. - - Type \code{vignette(package=""data.table"")} to get started. The \href{../doc/datatable-intro.html}{Introduction to data.table} vignette introduces \code{data.table}'s \code{x[i, j, by]} syntax and is a good place to start. If you have read the vignettes and the help page below, please read the \href{https://github.com/Rdatatable/data.table/wiki/Support}{data.table support guide}. - - Please check the \href{https://github.com/Rdatatable/data.table/wiki}{homepage} for up to the minute live NEWS. - - Tip: one of the \emph{quickest} ways to learn the features is to type \code{example(data.table)} and study the output at the prompt. -} -\usage{ -data.table(\dots, keep.rownames=FALSE, check.names=FALSE, key=NULL, stringsAsFactors=FALSE) - -\method{[}{data.table}(x, i, j, by, keyby, with = TRUE, - nomatch = NA, - mult = ""all"", - roll = FALSE, - rollends = if (roll==""nearest"") c(TRUE,TRUE) - else if (roll>=0) c(FALSE,TRUE) - else c(TRUE,FALSE), - which = FALSE, - .SDcols, - verbose = getOption(""datatable.verbose""), # default: FALSE - allow.cartesian = getOption(""datatable.allow.cartesian""), # default: FALSE - drop = NULL, on = NULL, env = NULL, - showProgress = getOption(""datatable.showProgress"", interactive())) -} -\arguments{ - \item{\dots}{ Just as \code{\dots} in \code{\link{data.frame}}. Usual recycling rules are applied to vectors of different lengths to create a list of equal length vectors.} - - \item{keep.rownames}{ If \code{\dots} is a \code{matrix} or \code{data.frame}, \code{TRUE} will retain the rownames of that object in a column named \code{rn}.} - - \item{check.names}{ Just as \code{check.names} in \code{\link{data.frame}}.} - - \item{key}{ Character vector of one or more column names which is passed to \code{\link{setkey}}.} - - \item{stringsAsFactors}{Logical (default is \code{FALSE}). Convert all \code{character} columns to \code{factor}s?} - - \item{x}{ A \code{data.table}.} - - \item{i}{ Integer, logical or character vector, single column numeric \code{matrix}, expression of column names, \code{list}, \code{data.frame} or \code{data.table}. - - \code{integer} and \code{logical} vectors work the same way they do in \code{\link{[.data.frame}} except logical \code{NA}s are treated as FALSE. - - \code{expression} is evaluated within the frame of the \code{data.table} (i.e. it sees column names as if they are variables) and can evaluate to any of the other types. - - \code{character}, \code{list} and \code{data.frame} input to \code{i} is converted into a \code{data.table} internally using \code{\link{as.data.table}}. - - If \code{i} is a \code{data.table}, the columns in \code{i} to be matched against \code{x} can be specified using one of these ways: - - \itemize{ - \item \code{on} argument (see below). It allows for both \code{equi-} and the newly implemented \code{non-equi} joins. - - \item If not, \code{x} \emph{must be keyed}. Key can be set using \code{\link{setkey}}. If \code{i} is also keyed, then first \emph{key} column of \code{i} is matched against first \emph{key} column of \code{x}, second against second, etc.. - ---- - -In this case, the un-exported function `[.data.table` will revert to calling `[.data.frame` as a safeguard since `data.table` has no way of knowing that the parent package is aware it's attempting to make calls against the syntax of `data.table`'s query API (which could lead to unexpected behavior as the structure of calls to `[.data.frame` and `[.data.table` fundamentally differ, e.g. the latter has many more arguments). - -If this is anyway your preferred approach to package development, please define `.datatable.aware = TRUE` anywhere in your R source code (no need to export). This tells `data.table` that you as a package developer have designed your code to intentionally rely on `data.table` functionality even though it may not be obvious from inspecting your `NAMESPACE` file. - -`data.table` determines on the fly whether the calling function is aware it's tapping into `data.table` with the internal `cedta` function (**C**alling **E**nvironment is **D**ata **T**able **A**ware), which, beyond checking the `?getNamespaceImports` for your package, also checks the existence of this variable (among other things). - -## Further information on dependencies - -For more canonical documentation of defining packages dependency check the official manual: [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html). - -## Importing data.table C routines - -Some of internally used C routines are now exported on C level thus can be used in R packages directly from their C code. See [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) for details and [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) _Linking to native routines in other packages_ section for usage. - -## Importing from non-r Applications {#non-r-api} - -Some tiny parts of `data.table` C code were isolated from the R C API and can now be used from non-R applications by linking to .so / .dll files. More concrete details about this will be provided later; for now you can study the C code that was isolated from the R C API in [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) and [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c). - -## How to convert your Depends dependency on data.table to Imports - -To convert a `Depends` dependency on `data.table` to an `Imports` dependency in your package, follow these steps: - -### Step 0. Ensure your package is passing R CMD check initially - -### Step 1. Update the DESCRIPTION file to put data.table in Imports, not Depends - -**Before:** -```dcf -Depends: - R (>= 3.5.0), - data.table -Imports: -``` - -**After:** -```dcf -Depends: - R (>= 3.5.0) -Imports: - data.table -``` - -### Step 2.1: Run `R CMD check` - -Run `R CMD check` to identify any missing imports or symbols. This step helps: - -- Automatically detect any functions or symbols from `data.table` that are not explicitly imported. -- Flag missing special symbols like `.N`, `.SD`, and `:=`. -- Provide immediate feedback on what needs to be added to the NAMESPACE file. - -Note: Not all such usages are caught by `R CMD check`. In particular, `R CMD check` skips some symbols/functions in formulas and will completely miss parsed expressions like `parse(text = ""data.table(a = 1)"")`. Packages will need good test coverage to detect these edge cases. - -### Step 2.2: Modify the NAMESPACE file - -Based on the `R CMD check` results, ensure all used functions, special symbols, S3 generics, and S4 classes from `data.table` are imported. - -That means adding `importFrom(data.table, ...)` directives for symbols, functions, and S3 generics, and/or `importClassesFrom(data.table, ...)` directives for S4 classes as appropriate. See 'Writing R Extensions' for full details on how to do so properly. - -#### Blanket import - -Alternatively, you can import all functions from `data.table` at once, though this is generally not recommended: - -```r -import(data.table) -``` - ---- - -The case for `data.table`'s special symbols (e.g. `.SD` and `.N`) and assignment operator (`:=`) is slightly different (see `?.N` for more, including a complete listing of such symbols). You should import whichever of these values you use from `data.table`'s namespace to protect against any issues arising from the unlikely scenario that we change the exported value of these in the future, e.g. if you want to use `.N`, `.I`, and `:=`, a minimal `NAMESPACE` would have: - -```r -importFrom(data.table, .N, .I, ':=') -``` - -Much simpler is to just use `import(data.table)` which will greedily allow usage in your package's code of any object exported from `data.table`. - -If you don't mind having `id` and `grp` registered as variables globally in your package namespace you can use `?globalVariables`. Be aware that these notes do not have any impact on the code or its functionality; if you are not going to publish your package, you may simply choose to ignore them. - -## Care needed when providing and using options - -Common practice by R packages is to provide customization options set by `options(name=val)` and fetched using `getOption(""name"", default)`. Function arguments often specify a call to `getOption()` so that the user knows (from `?fun` or `args(fun)`) the name of the option controlling the default for that parameter; e.g. `fun(..., verbose=getOption(""datatable.verbose"", FALSE))`. All `data.table` options start with `datatable.` so as to not conflict with options in other packages. A user simply calls `options(datatable.verbose=TRUE)` to turn on verbosity. This affects all data.table function calls unless `verbose=FALSE` is provided explicitly; e.g. `fun(..., verbose=FALSE)`. - -The option mechanism in R is _global_. Meaning that if a user sets a `data.table` option for their own use, that setting also affects code inside any package that is using `data.table` too. For an option like `datatable.verbose`, this is exactly the desired behavior since the desire is to trace and log all `data.table` operations from wherever they originate; turning on verbosity does not affect the results. Another unique-to-R and excellent-for-production option is R's `options(warn=2)` which turns all warnings into errors. Again, the desire is to affect any warning in any package so as to not miss any warnings in production. There are 6 `datatable.print.*` options and 3 optimization options which do not affect the result of operations. However, there is one `data.table` option that does and is now a concern: `datatable.nomatch`. This option changes the default join from outer to inner. [Aside, the default join is outer because outer is safer; it doesn't drop missing data silently; moreover it is consistent to base R way of matching by names and indices.] Some users prefer inner join to be the default and we provided this option for them. However, a user setting this option can unintentionally change the behavior of joins inside packages that use `data.table`. Accordingly, in v1.12.4 (Oct 2019) a message was printed when the `datatable.nomatch` option was used, and from v1.14.2 it is now ignored with warning. It was the only `data.table` option with this concern. - -## Troubleshooting - -If you face any problems in creating a package that uses data.table, please confirm that the problem is reproducible in a clean R session using the R console: `R CMD check package.name`. - ---- - -LIBRARY data.table.dll -EXPORTS - R_init_data_table - ---- - -## Importe optionnellement `data.table` : `Suggests` - -Si vous voulez utiliser `data.table` de manière conditionnelle, c'est-à-dire seulement quand il est installé, vous devriez utiliser `Suggests: data.table` dans votre fichier `DESCRIPTION` au lieu d'utiliser `Imports: data.table`. Par défaut, cette définition ne forcera pas l'installation de `data.table` lors de l'installation de votre package. Cela vous oblige aussi à utiliser conditionnellement `data.table` dans le code de votre package, ce qui doit être fait en utilisant la fonction `?requireNamespace`. L'exemple ci-dessous démontre l'utilisation conditionnelle de la fonction d'écriture de CSV rapide de `?fwrite` du package `data.table`. Si le package `data.table` n'est pas installé, la fonction de base R `?write.table`, beaucoup plus lente, est utilisée à la place. - -```r -my.write = function (x) { - if(requireNamespace(""data.table"", quietly=TRUE)) { - data.table::fwrite(x, ""data.csv"") - } else { - write.table(x, ""data.csv"") - } -} -``` - -Une version légèrement plus étendue de cette méthode permettrait également de s'assurer que la version installée de `data.table` est suffisamment récente pour que la fonction `fwrite` soit disponible : - -```r -my.write = function (x) { - if(requireNamespace(""data.table"", quietly=TRUE) && - utils::packageVersion(""data.table"") >= ""1.9.8"") { - data.table::fwrite(x, ""data.csv"") - } else { - write.table(x, ""data.csv"") - } -} -``` - -Lorsque vous utilisez un package comme dépendance suggérée, vous ne devez pas l'""importer"" dans le fichier `NAMESPACE`. Mentionnez-le simplement dans le fichier `DESCRIPTION`. Lorsque vous utilisez les fonctions `data.table` dans le code d'un package (fichiers R/*), vous devez utiliser le préfixe `data.table::` car aucune d'entre elles n'est importée. Lorsque vous utilisez `data.table` dans des packages de tests (par exemple des fichiers tests/testthat/test*), vous devez déclarer `.datatable.aware=TRUE` dans l'un des fichiers R/*. - -## `data.table` dans `Imports` mais rien d'importé - -Certains utilisateurs ([e.g.](https://github.com/Rdatatable/data.table/issues/2341)) peuvent préférer éviter d'utiliser `importFrom` ou `import` dans leur fichier `NAMESPACE` et utiliser à la place la syntaxe `data.table::` sur tout le code interne (en gardant bien sûr `data.table` sous leurs `Imports:` dans `DESCRIPTION`). - -Dans ce cas, la fonction non exportée `[.data.table` reviendra à appeler `[.data.frame` comme filet de sécurité puisque `data.table` n'a aucun moyen de savoir que le package parent est conscient qu'il tente de faire des appels en utilisant la syntaxe de l'API de requête de `data.table` (ce qui pourrait conduire à un comportement inattendu car la structure des appels à `[.data.frame` et `[.data.table` diffère fondamentalement, par exemple, ce dernier a beaucoup plus d'arguments). - -Si c'est l'approche que vous préférez pour le développement de packages, définissez `.datatable.aware = TRUE` n'importe où dans votre code source R (pas besoin d'exporter). Cela indique à `data.table` que vous, en tant que développeur du package, avez conçu votre code pour qu'il s'appuie intentionnellement sur les fonctionnalités de `data.table`, même si cela n'est pas évident en inspectant votre fichier `NAMESPACE`. - -`data.table` détermine à la volée si la fonction appelante est consciente qu'elle puise dans `data.table` avec la fonction interne `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), qui, en plus de vérifier le `?getNamespaceImports` de votre package, vérifie également l'existence de cette variable (entre autres choses). - -## Plus d'informations sur les dépendances - -Pour une documentation plus canonique sur la définition de la dépendance des packages, consultez le manuel officiel : [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html). - -## Importation des routines C de data.table - ---- - -### NOTES - - 1. Clearer explanation of what `duplicated()` does (borrowed from base). Thanks to @matthieugomez for pointing out. Closes [#872](https://github.com/Rdatatable/data.table/issues/872). - - 2. `?setnames` has been updated now that `names<-` and `colnames<-` shallow (rather than deep) copy from R >= 3.1.0, [#853](https://github.com/Rdatatable/data.table/issues/853). - - 3. [FAQ 1.6](https://github.com/Rdatatable/data.table/wiki/vignettes/datatable-faq.pdf) has been embellished, [#517](https://github.com/Rdatatable/data.table/issues/517). Thanks to a discussion with Vivi and Josh O'Brien. - - 4. `data.table` redefines `melt` generic and *suggests* `reshape2` instead of *import*. As a result we don't have to load `reshape2` package to use `melt.data.table` anymore. The reason for this change is that `data.table` requires R >=2.14, whereas `reshape2` R v3.0.0+. Reshape2's melt methods can be used without any issues by loading the package normally. - - 5. `DT[, j, ]` at times made an additional (unnecessary) copy. This is now fixed. This fix also avoids allocating `.I` when `j` doesn't use it. As a result `:=` and other subset operations should be faster (and use less memory). Thanks to @szilard for the nice report. Closes [#921](https://github.com/Rdatatable/data.table/issues/921). - - 6. Because `reshape2` requires R >3.0.0, and `data.table` works with R >= 2.14.1, we can not import `reshape2` anymore. Therefore we define a `melt` generic and `melt.data.table` method for data.tables and redirect to `reshape2`'s `melt` for other objects. This is to ensure that existing code works fine. - - 7. `dcast` is also a generic now in data.table. So we can use `dcast(...)` directly, and don't have to spell it out as `dcast.data.table(...)` like before. The `dcast` generic in data.table redirects to `reshape2::dcast` if the input object is not a data.table. But for that you have to load `reshape2` before loading `data.table`. If not, reshape2's `dcast` overwrites data.table's `dcast` generic, in which case you will need the `::` operator - ex: `data.table::dcast(...)`. - - NB: Ideal situation would be for `dcast` to be a generic in reshape2 as well, but it is not. We have issued a [pull request](https://github.com/hadley/reshape/pull/62) to make `dcast` in reshape2 a generic, but that has not yet been accepted. - - 8. Clarified the use of `bit64::integer4` in `merge.data.table()` and `setNumericRounding()`. Closes [#1093](https://github.com/Rdatatable/data.table/issues/1093). Thanks to @sfischme for the report. - - 9. Removed an unnecessary (and silly) `giveNames` argument from `setDT()`. Not sure why I added this in the first place! - - 10. `options(datatable.prettyprint.char=5L)` restricts the number of characters to be printed for character columns. For example: - ``` - options(datatable.prettyprint.char = 5L) - DT = data.table(x=1:2, y=c(""abcdefghij"", ""klmnopqrstuv"")) - DT - # x y - # 1: 1 abcde... - # 2: 2 klmno... - ```` - - 11. `rolltolast` argument in `[.data.table` is now defunct. It was deprecated in 1.9.4. - - 12. `data.table`'s dependency has been moved forward from R 2.14.0 to R 2.14.1, now nearly 4 years old (Dec 2011). As usual before release to CRAN we ensure data.table passes the test suite on the stated dependency and keep this as old as possible for as long as possible. As requested by users in managed environments. For this reason we still don't use `paste0()` internally, since that was added to R 2.15.0. - - 13. Warning about `datatable.old.bywithoutby` option (for grouping on join without providing `by`) being deprecated in the next release is in place now. Thanks to @jangorecki for the PR. - - 14. Fixed `allow.cartesian` documentation to `nrow(x)+nrow(i)` instead of `max(nrow(x), nrow(i))`. Closes [#1123](https://github.com/Rdatatable/data.table/issues/1123). - -## data.table v1.9.4 (on CRAN 2 Oct 2014) - -### NEW FEATURES - ---- - -## Importation des routines C de data.table - -Certaines routines C utilisées en interne sont maintenant exportées au niveau C et peuvent donc être utilisées dans les packages R directement à partir de leur code C. Voir [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) pour les détails et [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) dans la section *Linking to native routines in other packages* pour l'utilisation. - -## Importation à partir d'applications non-r {#non-r-api} - -Certaines petites parties du code C de `data.table` ont été isolées de l'API C de R et peuvent maintenant être utilisées à partir d'applications non-R en liant les fichiers .so / .dll. Des détails plus concrets seront fournis ultérieurement ; pour l'instant, vous pouvez étudier le code C qui a été isolé de l'API C de R dans [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) et [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c). - -## Comment convertir votre dépendance à data.table de Depends à Imports - -Pour convertir une dépendance `Depends` sur `data.table` en une dépendance `Imports` dans votre package, suivez ces étapes : - -### Étape 0. S'assurer que votre package passe le contrôle R CMD dans un premier temps - -### Étape 1. Mettre à jour le fichier DESCRIPTION pour placer data.table dans Imports, et non dans Depends - -**Avant :** - -```dcf -Depends: - R (>= 3.5.0), - data.table -Imports: -``` - -**Après :** - -```dcf -Depends: - R (>= 3.5.0) -Imports: - data.table -``` - -### Étape 2.1 : Exécuter `R CMD check` - -Lancez `R CMD check` pour identifier tout import ou symbole manquant. Cette étape aide à : - -- Détecter automatiquement toutes les fonctions ou symboles de `data.table` qui ne sont pas explicitement importés. -- Signaler les symboles spéciaux manquants comme `.N`, `.SD`, et `:=`. -- Fournir immédiatement une information sur ce qui doit être ajouté au fichier NAMESPACE. - -Note : Toutes ces utilisations ne sont pas prises en compte par `R CMD check`. En particulier, `R CMD check` ne tient pas compte de certains symboles/fonctions dans les formules et manquera complètement des expressions analysées comme `parse(text = ""data.table(a = 1)"")`. Les packages auront besoin d'une bonne couverture de test pour détecter ces cas limites. - -### Étape 2.2 : Modifier le fichier NAMESPACE - -En se basant sur les résultats du `R CMD check`, s'assurer que toutes les fonctions utilisées, les symboles spéciaux, les génériques S3, et les classes S4 de `data.table` sont importés. - -Cela signifie qu'il faut ajouter les directives `importFrom(data.table, ...)` pour les symboles, les fonctions et les génériques S3, et/ou les directives `importClassesFrom(data.table, ...)` pour les classes S4, selon le cas. Voir 'Writing R Extensions' pour plus de détails sur la façon de procéder. - -#### Importation complète - -Vous pouvez également importer toutes les fonctions de `data.table` en une seule fois, bien que cela ne soit généralement pas recommandé : - -```r -import(data.table) -``` - -**Justification Pour Eviter Les Importations Globales :** =====1. **Documentation** : Le fichier NAMESPACE peut servir de bonne documentation sur la façon dont vous dépendez de certains packages. -2. **Éviter Les Conflits** : Les importations générales vous exposent à des ruptures subtiles. Par exemple, si vous importez deux packages avec `import(pkgA)` et `import(pkgB)`, mais que plus tard pkgB exporte une fonction également exportée par pkgA, cela cassera votre package à cause de conflits dans votre espace de noms, ce qui est interdit par `R CMD check` et CRAN.===== - -### Étape 3 : Mettre à jour vos fichiers de code R en dehors du répertoire R/ du package - ---- - -it means that R is looking for a DLL for the modified data.table package, for a specific version, but it can't find it. The fix is to provide pkg.edit.fun which is defined here https://github.com/Rdatatable/data.table/blob/master/.ci/atime/tests.R - -Requested object could not be found - -When running atime_versions to prototype a new performance test, as in the code below: - -## Adapted from https://github.com/Rdatatable/data.table/issues/6662#issue-2737165196 -alist <- atime::atime_versions( - ""~/R/data.table"", - pkg.edit.fun = function(old.Package, new.Package, sha, new.pkg.path) { - pkg_find_replace <- function(glob, FIND, REPLACE) { - atime::glob_find_replace(file.path(new.pkg.path, glob), FIND, REPLACE) - } - Package_regex <- gsub(""."", ""_?"", old.Package, fixed = TRUE) - Package_ <- gsub(""."", ""_"", old.Package, fixed = TRUE) - new.Package_ <- paste0(Package_, ""_"", sha) - pkg_find_replace( - ""DESCRIPTION"", - paste0(""Package:\\s+"", old.Package), - paste(""Package:"", new.Package)) - pkg_find_replace( - file.path(""src"", ""Makevars.*in""), - Package_regex, - new.Package_) - pkg_find_replace( - file.path(""R"", ""onLoad.R""), - Package_regex, - new.Package_) - pkg_find_replace( - file.path(""R"", ""onLoad.R""), - sprintf('packageVersion\\(""%s""\\)', old.Package), - sprintf('packageVersion\\(""%s""\\)', new.Package)) - pkg_find_replace( - file.path(""src"", ""init.c""), - paste0(""R_init_"", Package_regex), - paste0(""R_init_"", gsub(""[.]"", ""_"", new.Package_))) - # allow compilation on new R versions where 'Calloc' is not defined - pkg_find_replace( - file.path(""src"", ""*.c""), - ""\\b(Calloc|Free|Realloc)\\b"", - ""R_\\1"") - pkg_find_replace( - ""NAMESPACE"", - sprintf('useDynLib\\(""?%s""?', Package_regex), - paste0('useDynLib(', new.Package_)) - }, - Fast=""ee44ef45814115003d1499284227af6f5e487ad3"",# Last commit in the PR (https://github.com/Rdatatable/data.table/pull/6679/commits) that implemented the new feature. - Slow=""4a2474b59637aad9e032b1eaee6e9bdcfc4df949"",# Parent of the first commit (https://github.com/Rdatatable/data.table/commit/60828522cb1dbf696ce32a7323464d9d8870b9f6) in the PR (https://github.com/Rdatatable/data.table/pull/6679/commits) that implemented the new feature. - setup={ - set.seed(1234) - DT <- data.table(x=runif(N),y=runif(N)) - }, - expr=data.table:::sort_by.data.table(DT, ~ x + y)) - -it is possible to get an error like below: - -Error in value[[3L]](cond) : - Error in revparse_single(object, branch): Error in 'git2r_revparse_single': Requested object could not be found - - when trying to checkout ee44ef45814115003d1499284227af6f5e487ad3 -Timing stopped at: 0.48 1.15 4.38 - -This indicates that the commit can not be found in the git repo. In this case the commit is the Fast commit, in the PR which implemented the new feature. This happens because for most branches, data.table devs will click on the ""Delete branch"" button on the PR page, after merging the PR. The fix is to go to the PR page, and click the ""Restore branch"" button. If you don't know what branch it is, then you can go to the commit page, https://github.com/Rdatatable/data.table/commit/ee44ef45814115003d1499284227af6f5e487ad3 in this example, and there should be a link to the corresponding PR, as shown below. - -image - -Related team - -A team, Performance Testers is assigned to one who is actively involved with the performance testing aspects of data.table. Responsibilities that fall under this specialized role can include, but are not restricted to: - -Evaluating the scalability of data.table functions to track how they perform as datasets grow asymptotically. - -Running comparative performance benchmarks to portray the relative efficiency of operations, i.e., in contrast to other packages that achieve similar functionality as data.table. - ---- - -\name{tables} -\alias{tables} -\title{Display 'data.table' metadata } -\description{ - Convenience function for concisely summarizing some metadata of all \code{data.table}s in memory (or an optionally specified environment). -} -\usage{ -tables(mb=type_size, order.col=""NAME"", width=80, - env=parent.frame(), silent=FALSE, index=FALSE) -} -\arguments{ - \item{mb}{ a function which accepts a \code{data.table} and returns its size in bytes. By default, \code{type_size} (same as \code{TRUE}) provides a fast lower bound by excluding the size of character strings in R's global cache (which may be shared) and excluding the size of list column items (which also may be shared). A column \code{""MB""} is included in the output unless \code{FALSE} or \code{NULL}. } - \item{order.col}{ Column name (\code{character}) by which to sort the output. } - \item{width}{ \code{integer}; number of characters beyond which the output for each of the columns \code{COLS}, \code{KEY}, and \code{INDICES} are truncated. } - \item{env}{ An \code{environment}, typically the \code{.GlobalEnv} by default, see Details. } - \item{silent}{ \code{logical}; should the output be printed? } - \item{index}{ \code{logical}; if \code{TRUE}, the column \code{INDICES} is added to indicate the indices assorted with each object, see \code{\link{indices}}. } -} -\details{ -Usually \code{tables()} is executed at the prompt, where \code{parent.frame()} returns \code{.GlobalEnv}. \code{tables()} may also be useful inside functions where \code{parent.frame()} is the local scope of the function; in such a scenario, simply set it to \code{.GlobalEnv} to get the same behaviour as at prompt. - -\code{mb = utils::object.size} provides a higher and more accurate estimate of size, but may take longer. Its default \code{units=""b""} is appropriate. - -Setting \code{silent=TRUE} prints nothing; the metadata is returned as a \code{data.table} invisibly whether \code{silent} is \code{TRUE} or \code{FALSE}. -} -\value{ - A \code{data.table} containing the information printed. -} -\seealso{ \code{\link{data.table}}, \code{\link{setkey}}, \code{\link{ls}}, \code{\link{objects}}, \code{\link{object.size}} } -\examples{ -DT = data.table(A=1:10, B=letters[1:10]) -DT2 = data.table(A=1:10000, ColB=10000:1) -setkey(DT,B) -tables() -} -\keyword{ data } - ---- - ---- -title: ""Introduction to data.table"" -date: ""`{r} Sys.Date()`"" -output: - litedown::html_format -vignette: > - %\VignetteIndexEntry{Introduction to data.table} - %\VignetteEngine{litedown::vignette} - \usepackage[utf8]{inputenc} ---- - -```{r, echo=FALSE, file='_translation_links.R'} -``` -`{r} .write.translation.links(""Translations of this document are available in: %s"")` - -```{r, echo = FALSE, message = FALSE} -library(data.table) -litedown::reactor(comment = ""# "") -.old.th = setDTthreads(1) -``` - -This vignette introduces the `data.table` syntax, its general form, how to *subset* rows, *select and compute* on columns, and perform aggregations *by group*. Familiarity with the `data.frame` data structure from base R is useful, but not essential to follow this vignette. - -*** - -## Data analysis using `data.table` - -Data manipulation operations such as *subset*, *group*, *update*, *join*, etc. are all inherently related. Keeping these *related operations together* allows for: - -* *concise* and *consistent* syntax irrespective of the set of operations you would like to perform to achieve your end goal. - -* performing analysis *fluidly* without the cognitive burden of having to map each operation to a particular function from a potentially huge set of functions available before performing the analysis. - -* *automatically* optimising operations internally and very effectively by knowing precisely the data required for each operation, leading to very fast and memory-efficient code. - -Briefly, if you are interested in reducing *programming* and *compute* time tremendously, then this package is for you. The philosophy that `data.table` adheres to makes this possible. Our goal is to illustrate it through this series of vignettes. - -## Data {#data} - -In this vignette, we will use [NYC-flights14](https://raw.githubusercontent.com/Rdatatable/data.table/master/vignettes/flights14.csv) data obtained from the [flights](https://github.com/arunsrinivasan/flights) package (available on GitHub only). It contains On-Time flights data from the Bureau of Transportation Statistics for all the flights that departed from New York City airports in 2014 (inspired by [nycflights13](https://github.com/tidyverse/nycflights13)). The data is available only for Jan-Oct'14. - -We can use `data.table`'s fast-and-friendly file reader `fread` to load `flights` directly as follows: - -```{r, echo = FALSE} -options(width = 100L) -``` - -```{r} -input <- if (file.exists(""flights14.csv"")) { - ""flights14.csv"" -} else { - ""https://raw.githubusercontent.com/Rdatatable/data.table/master/vignettes/flights14.csv"" -} -flights <- fread(input) -flights -dim(flights) -``` - -Aside: `fread` accepts `http` and `https` URLs directly, as well as operating system commands such as `sed` and `awk` output. See `?fread` for examples. - -## Introduction - -In this vignette, we will - -1. Start with the basics - what is a `data.table`, its general form, how to *subset* rows, how to *select and compute* on columns; - -2. Then we will look at performing data aggregations by group - -## 1. Basics {#basics-1} - -### a) What is `data.table`? {#what-is-datatable-1a} - -`data.table` is an R package that provides **an enhanced version** of a `data.frame`, the standard data structure for storing data in `base` R. In the [Data](#data) section above, we saw how to create a `data.table` using `fread()`, but alternatively we can also create one using the `data.table()` function. Here is an example: - -```{r} -DT = data.table( - ID = c(""b"",""b"",""b"",""a"",""a"",""c""), - a = 1:6, - b = 7:12, - c = 13:18 -) -DT -class(DT$ID) -``` - -You can also convert existing objects to a `data.table` using `setDT()` (for `data.frame` and `list` structures) or `as.data.table()` (for other structures). For more details pertaining to the difference (goes beyond the scope of this vignette), please see `?setDT` and `?as.data.table`. - -#### Note that: - -* Row numbers are printed with a `:` in order to visually separate the row number from the first column. - ---- - -back to data.table after a long time with dplyr #rstats - -25 Dec 2014 Hadley Wickham on Hacker News - -Data tables are extremely fast but I think their concision makes it harder to learn and code that uses it is harder to read after you've written it. It's very reminiscent of APL. - -Our response: See the hacker news item and comparing dplyr to data.table on Stack Overflow. The word reminiscent was used to convey the notion of-the-past and is meant as criticism. Note that Hadley was responding to a positive post about data.table on Hacker News. The original item was : - -Anyone doing R comparisons should use data.table instead of data.frame. More so for benchmarks. data.table is the best data structure/query language I have found in my career. It's leading the way in The R world, and in my way, in all the data-focused languages. - -Hadley sought to shoot down this positive sentiment. His negative sentiment is what has stuck in the community rather than the original post which was positive. That's what works. - -26 Jun 2014 Hadley Wickham on Stack Overflow - -Also read.csv() reads everything into a big character matrix and then modifies that, does fread() do the same thing? In fastread we guess column types and then coerce as we go to avoid a complete copy of the df. - -The Stack Overflow question is ""Reason behind speed of fread in data.table package in R"" and an implicit compliment to data.table. That's the context. The comment is a subtle way to i) create doubt about fread and ii) announce his new fastread package which had not been known before that. fastread subsequently became readr. - ---- - -Según los resultados de `R CMD check`, asegúrese de que se importen todas las funciones utilizadas, los símbolos especiales, los genéricos S3 y las clases S4 de `data.table`. - -Esto implica agregar directivas `importFrom(data.table, ...)` para símbolos, funciones y genéricos de S3, o directivas `importClassesFrom(data.table, ...)` para clases de S4, según corresponda. Consulte ""Escritura de extensiones de R"" para obtener más información sobre cómo hacerlo correctamente. - -#### Importación completa - -Como alternativa, puede importar todas las funciones de `data.table` a la vez, aunque esto generalmente no se recomienda: - -```r -import(data.table) -``` - -**Justificación para evitar importaciones generales:** -1. **Documentación**: El archivo NAMESPACE puede servir como buena documentación de cómo depende de ciertos paquetes. -2. **Evitar conflictos**: Las importaciones generales pueden causar fallos sutiles. Por ejemplo, si importa `import(pkgA)` e `import(pkgB)`, pero posteriormente pkgB exporta una función también exportada por pkgA, esto romperá su paquete debido a conflictos en su espacio de nombres, lo cual no está permitido por `R CMD check` y CRAN. - -### Paso 3: Actualice sus archivos de código R fuera del directorio R/ del paquete - -Al mover un paquete de ""Depends"" a ""Imports"", ya no se adjuntará automáticamente al cargarlo. Esto puede ser importante para ejemplos, pruebas, viñetas y demostraciones, donde los paquetes de ""Imports"" deben adjuntarse explícitamente. - -**Antes (con `Depends`):** - -```r -# data.table functions are directly available -library(MyPkgDependsDataTable) -dt <- data.table(x = 1:10, y = letters[1:10]) -setDT(dt) -result <- merge(dt, other_dt, by = ""x"") -``` - -**Después (con `Imports`):** - -```r -# Explicitly load data.table in user scripts or vignettes -library(data.table) -library(MyPkgDependsDataTable) -dt <- data.table(x = 1:10, y = letters[1:10]) -setDT(dt) -result <- merge(dt, other_dt, by = ""x"") -``` - -### Beneficios de usar `Imports` - -- **Facilidad de uso**: `Depends` modifica la ruta `search()` de los usuarios, posiblemente sin su consentimiento. -- **Gestión del espacio de nombres**: Solo están disponibles las funciones que tu paquete importa explícitamente, lo que reduce el riesgo de conflictos de nombres de funciones. -- **Carga de paquetes más limpia**: Las dependencias de tu paquete no se vinculan a la ruta de búsqueda, lo que hace que el proceso de carga sea más limpio y potencialmente más rápido. -- **Mantenimiento más sencillo**: Simplifica las tareas de mantenimiento a medida que evolucionan las API de las dependencias ascendentes. Depender demasiado de `Depends` puede generar conflictos y problemas de compatibilidad con el tiempo. - -```{r, echo = FALSE, message = FALSE} -data.table::setDTthreads(.old.th) -``` - ---- - -#: onAttach.R:26 -#, c-format -msgid ""Latest news: r-datatable.com"" -msgstr ""Últimas notícias: r-datatable.com"" - -#: onAttach.R:27 -msgid ""TRANSLATION CHECK"" -msgstr ""VERIFICAÇÃO DE TRADUÇÃO"" - -#: onAttach.R:29 -#, c-format -msgid """" -""**********\n"" -""Running data.table in English; package support is available in English only. "" -""When searching for online help, be sure to also check for the English error "" -""message. This can be obtained by looking at the po/R-.po and po/"" -"".po files in the package source, where the native language and "" -""English error messages can be found side-by-side.%s\n"" -""**********"" -msgstr """" -""**********\n"" -""Executando data.table em português; o suporte ao pacote está disponível "" -""apenas em inglês. Ao procurar ajuda online, certifique-se de verificar "" -""também a mensagem de erro em inglês. Isso pode ser obtido examinando os "" -""arquivos po/R-pt_BR.po e po/pt_BR.po no código-fonte do pacote, onde as "" -""mensagens de erro no idioma nativo e em inglês podem ser encontradas lado a "" -""lado.%s\n"" -""**********"" - -#: onAttach.R:30 -msgid """" -""You can also try calling Sys.setLanguage('en') prior to reproducing the "" -""error message."" -msgstr """" -""Você também pode tentar chamar Sys.setLanguage('en') antes de reproduzir a "" -""mensagem de erro."" - -#: onAttach.R:34 -#, c-format -msgid """" -""**********\n"" -""This development version of data.table was built more than 4 weeks ago. "" -""Please update: data.table::update_dev_pkg()\n"" -""**********"" -msgstr """" -""**********\n"" -""Esta versão de desenvolvimento do data.table foi construída há mais de 4 "" -""semanas. Por favor, atualize: data.table::update_dev_pkg()\n"" -""**********"" - -#: onAttach.R:36 -#, c-format -msgid """" -""**********\n"" -""This installation of data.table has not detected OpenMP support. It should "" -""still work but in single-threaded mode."" -msgstr """" -""**********\n"" -""Esta instalação do data.table não detectou suporte ao OpenMP. Ainda deve "" -""funcionar, mas em modo de single-threaded."" - -#: onAttach.R:38 -#, c-format -msgid """" -""This is a Mac. Please read https://mac.r-project.org/openmp/. Please engage "" -""with Apple and ask them for support. Check r-datatable.com for updates, and "" -""our Mac instructions here: https://github.com/Rdatatable/data.table/wiki/"" -""Installation. After several years of many reports of installation problems "" -""on Mac, it's time to gingerly point out that there have been no similar "" -""problems on Windows or Linux.\n"" -""**********"" -msgstr """" -""Este é um Mac. Por favor, leia https://mac.r-project.org/openmp/. Por favor, "" -""envolva-se com a Apple e peça suporte. Verifique r-datatable.com para "" -""atualizações e nossas instruções para Mac aqui: https://github.com/"" -""Rdatatable/data.table/wiki/Installation. Após vários anos de muitos relatos "" -""de problemas de instalação no Mac, é hora de apontar cuidadosamente que não "" -""houve problemas semelhantes no Windows ou Linux.\n"" -""**********"" - -#: onAttach.R:40 -#, c-format -msgid """" -""This is %s. This warning should not normally occur on Windows or Linux where "" -""OpenMP is turned on by data.table's configure script by passing -fopenmp to "" -""the compiler. If you see this warning on Windows or Linux, please file a "" -""GitHub issue.\n"" -""**********"" -msgstr """" -""Este é %s. Este aviso normalmente não deve ocorrer no Windows ou Linux, onde "" -""o OpenMP é ativado pelo script de configuração do data.table passando "" -""-fopenmp para o compilador. Se você vir este aviso no Windows ou Linux, por "" -""favor, relate no rastreador de problemas no GitHub.\n"" -""**********"" - -#: onLoad.R:5 -#, c-format -msgid """" -""Option 'datatable.nomatch' is defined but is now ignored. Please see note 11 "" -""in v1.12.4 NEWS (Oct 2019), and note 14 in v1.14.2."" -msgstr """" -""Opção 'datatable.nomatch' está definida, mas agora é ignorada. Por favor, "" -""veja a nota 11 nas notícias de v1.12.4 (Outubro de 2019) e a nota 14 em "" -""v1.14.2."" - ---- - -![Grouping, Illustrated](plots/grouping_illustration.png) - - -In the case of grouping, `.SD` is multiple in nature -- it refers to _each_ of these sub-`data.table`s, _one-at-a-time_ (slightly more accurately, the scope of `.SD` is a single sub-`data.table`). This allows us to concisely express an operation that we'd like to perform on _each sub-`data.table`_ before the re-assembled result is returned to us. - -This is useful in a variety of settings, the most common of which are presented here: - -## Group Subsetting - -Let's get the most recent season of data for each team in the Lahman data. This can be done quite simply with: - -```{r group_sd_last} -# the data is already sorted by year; if it weren't -# we could do Teams[order(yearID), .SD[.N], by = teamID] -Teams[ , .SD[.N], by = teamID] -``` - -Recall that `.SD` is itself a `data.table`, and that `.N` refers to the total number of rows in a group (it's equal to `nrow(.SD)` within each group), so `.SD[.N]` returns the _entirety of `.SD`_ for the final row associated with each `teamID`. - -Another common version of this is to use `.SD[1L]` instead to get the _first_ observation for each group, or `.SD[sample(.N, 1L)]` to return a _random_ row for each group. - -## Group Optima - -Suppose we wanted to return the _best_ year for each team, as measured by their total number of runs scored (`R`; we could easily adjust this to refer to other metrics, of course). Instead of taking a _fixed_ element from each sub-`data.table`, we now define the desired index _dynamically_ as follows: - -```{r sd_team_best_year} -Teams[ , .SD[which.max(R)], by = teamID] -``` - -Note that this approach can of course be combined with `.SDcols` to return only portions of the `data.table` for each `.SD` (with the caveat that `.SDcols` should be fixed across the various subsets). - -_NB_: `.SD[1L]` is currently optimized by [_`GForce`_](https://Rdatatable.gitlab.io/data.table/library/data.table/html/datatable-optimize.html) ([see also](https://stackoverflow.com/questions/22137591/about-gforce-in-data-table-1-9-2)), `data.table` internals which massively speed up the most common grouped operations like `sum` or `mean` -- see `?GForce` for more details and keep an eye on/voice support for feature improvement requests for updates on this front: [1](https://github.com/Rdatatable/data.table/issues/735), [2](https://github.com/Rdatatable/data.table/issues/2778), [3](https://github.com/Rdatatable/data.table/issues/523), [4](https://github.com/Rdatatable/data.table/issues/971), [5](https://github.com/Rdatatable/data.table/issues/1197), [6](https://github.com/Rdatatable/data.table/issues/1414). - -## Grouped Regression - -Returning to the inquiry above regarding the relationship between `ERA` and `W`, suppose we expect this relationship to differ by team (i.e., there's a different slope for each team). We can easily re-run this regression to explore the heterogeneity in this relationship as follows (noting that the standard errors from this approach are generally incorrect -- the specification `ERA ~ W*teamID` will be better -- this approach is easier to read and the _coefficients_ are OK): - ---- - -Ainsi, data.table peut hériter de `data.frame` sans utiliser `...`. Si nous utilisions `...`, les noms d'arguments invalides ne seraient pas détectés. - -L'argument `drop` n'est jamais utilisé par `[.data.table`. C'est un substitut pour les packages non compatibles avec data.table lorsqu'ils utilisent la syntaxe `[.data.frame` directement sur un data.table. - -## Les jonctions par roulement sont cool et très rapides ! C'était difficile à programmer ? - -La ligne dominante sur ou avant la ligne `i` est la ligne finale que la recherche binaire teste de toute façon. Donc `roll = TRUE` est essentiellement un interrupteur dans le code C de la recherche binaire pour retourner cette ligne. - -## Pourquoi `DT[i, col := valeur]` retourne-t-il la totalité de `DT` ? Je m'attendais à ce qu'il n'y ait pas de valeur visible (ce qui est cohérent avec `<-`), ou à ce qu'il y ait un message ou une valeur de retour contenant le nombre de lignes mises à jour. Il n'est pas évident que les données aient été mises à jour par référence. - -Ceci a été modifié dans la version 1.8.3 pour répondre à vos attentes. Veuillez mettre à jour. - -L'ensemble de `DT` est retourné (maintenant de manière invisible) pour que la syntaxe composée puisse fonctionner ; *e.g.*, `DT[i, done := TRUE][ , sum(done)]`. Le nombre de lignes mises à jour est retourné quand `verbose` est `TRUE`, soit sur une base par requête, soit globalement en utilisant `options(datatable.verbose = TRUE)`. - -## D'accord, merci. Qu'y a-t-il de si difficile dans le fait que le résultat de `DT[i, col := value]` soit renvoyé de façon invisible ? - -R force en interne la visibilité pour `[`. La valeur de la colonne eval de FunTab (voir [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) pour `[` est `0` ce qui signifie ""force `R_Visible` on"" (voir [R-Internals section 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting) ). Par conséquent, lorsque nous avons essayé `invisible()` ou de mettre `R_Visible` à `0` directement nous-mêmes, `eval` dans [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) l'a forcé à nouveau. - -Pour résoudre ce problème, la clé était de ne plus essayer d'arrêter l'exécution de la méthode print après un `:=`. Au lieu de cela, à l'intérieur de `:=` nous mettons maintenant (à partir de la version 1.8.3) un drapeau global que la méthode print utilise pour savoir si elle doit imprimer ou non. - -## Pourquoi dois-je taper `DT` parfois deux fois après avoir utilisé `:=` pour imprimer le résultat dans la console ? - -C'est un inconvénient malheureux pour faire fonctionner [#869](https://github.com/Rdatatable/data.table/issues/869). Si un `:=` est utilisé à l'intérieur d'une fonction sans `DT[]` avant la fin de la fonction, alors la prochaine fois que `DT` est tapé à l'invite, rien ne sera affiché. Un `DT` répété sera affiché. Pour éviter cela : incluez un `DT[]` après le dernier `:=` dans votre fonction. Si ce n'est pas possible (par exemple, ce n'est pas une fonction que vous pouvez changer), alors `print(DT)` et `DT[]` à l'invite sont garantis de s’afficher. Comme précédemment, l'ajout d'un `[]` supplémentaire à la fin de la requête `:=` est un idiome recommandé pour mettre à jour et ensuite imprimer ; e.g.> `DT[,foo:=3L][]`. - -## J'ai remarqué que `base::cbind.data.frame` (et `base::rbind.data.frame`) semble être modifié par data.table. Comment cela est-il possible ? Pourquoi ? - ---- - -HTML vignettes - -Introduction to data.table - -Reference semantics - -Keys and fast binary search based subsets - -Secondary indices and auto indexing - -Efficient reshaping using data.tables - -Frequently asked questions - -Documentation and examples - -?data.table - -?fread - -pdf manual - -devel html manual - -cheat sheet - -in-depth tables tutorial - -Questions & Answers - -community support on data.table stackoverflow tag - -Read [[Support]] wiki on how to properly ask questions and additional information about support. - -Notices/discussion - -Follow #rdatatable - -Click the 'watch' button at the top and right of this page (next to star and fork) - -User reviews - -Crantastic - -Learn by doing - -data.table course on DataCamp - ---- - -2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk - -2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse - -2019.07 : Bayesian analysis with Stan & Data manipulation with data.table, Jared Kai Swan, Los Angeles East - -2019.07 : Start using data.table, Megan Stodel, Ministry of Justice Coffee and Coding - -2019.07 : Wrangling 4.6M rows of Financial Data (Home Loans Time Series) in R with data.table, Matt Dancho, Business Science Learning Lab - -2019.07 : data.table: a slide deck of data.table piping Gina Reynolds, slides - -2019.06 : why data.table?, Jan Gorecki, Poznan R User Group - -2019.05 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O Meetup Mountain View - -2019.05 : Workshop: Getting Started in R and data.table - Saghir Bashir, ilustat.com - -2019.04 : Pipes or Brackets: dplyr and data.table, Jeremy Guinta & Amy Linehan, satRday LA - -2019.02 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O World San Francisco - -2019.01 : Introduction to Automatic and Scalable Machine Learning with H2O and R (afternoon session data.table), Dmytro Perepolkin and Raoul Wolf, University of Oslo Library - -2018.12 : Workshop: Getting Started in R and data.table, Saghir Bashir, Data Science Unplugged Lisbon - -2018.10 : data.table for R, Python and updated-daily benchmarks, Matt Dowle, H2OWorld London - -2018.09 : Life in the Fast Lane: data.table Intro and Best Practices, Bill Gold, New York OSPM - -2018.09 : ALTREP from a data.table perspective, Matt Dowle, DSC Stanford I talked ad-lib and showed code on screen; no slides. - -2018.09 : Tutorial: efficient data manipulation with data.table, Jaap Walhout, uRos The Hague - -2018.08 : Success with OpenMP in R package data.table, Matt Dowle, JSM Vancouver - -2018.07 : 12 years of data.table (past, present and future), Arun Srinivasan, R in Montreal - -2018.07 : What's new in data.table, Jan Gorecki, WhyR Wroclaw - -2018.06 : Data munging in driverless.ai with datatable, Pasha Stetsenko, H2OWorld New York - -2018.05 : Top 10 reasons to use data.table; O Jossome, T Robert and F Meyer, dreamRs 2018 - -2018.05 : The beauty of data manipulation with data.table, János Divényi, eRum Budapest - -2017.12 : data.table, Matt Dowle, H2O World Mountain View - -2017.11 : data.table, Sebastian Jeworutzki, useR! Bochum - -2017.07 : data.table for beginners (tutorial), Arun Srinivasan, useR! Brussels - -2017.04 : Parallel fread and other news from data.table, Matt Dowle, Bay Area RUG - -2017.04 : data.table power hour, Steph Locke, SQLBits London - -2017.01 : New developments in the data.table package, Arun Srinivasan, AmstRdam RUG - -2016.09 : Data manipulation the #rdatatable way, Arun Srinivasan, SatRdays Budapest - -2016.07 : Parallel and distributed ordered join benchmark, Matt Dowle, H2O Open Tour New York - -2016.07 : Proposal for parallel sort in base R (and Python/Julia), Matt Dowle, DSC Stanford - -2016.06 : Efficient in-memory non-equi joins, Arun Srinivasan, useR! Stanford - -2016.06 : Ninja Moves with data.table 3hr tutorial, Matt Dowle & Arun Srinivasan, useR! Stanford - -2016.05 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin - -2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, Data by the Bay San Francisco - -2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, H2O Open Tour Chicago - -2016.05 : R Lecture #3: data.table, Peter Hurford - -2016.02 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin - -2016.02 Parallel and Distributed Joining, Matt Dowle, Bay Area R User Group - -2016.01 Invited lecture by Matt Dowle at Stat290 Paradigms for Computing with Data, Stanford - -2016.01 Invited lecture by Matt Dowle at FNCE3490 Data Science and Business Analytics, Santa Clara University - -2016.01 data table discussion, Gaurav Chaturedi & Nicholas Ng, Singapore R User Group - ---- - -15. `mult=""all""` -vs- `mult=""first""|""last""` now return consistent types and columns, [#340](https://github.com/Rdatatable/data.table/issues/340). Thanks to Michele Carriero for highlighting. - - 16. `duplicated.data.table` and `unique.data.table` gains `fromLast = TRUE/FALSE` argument, similar to base. Default value is FALSE. Closes [#347](https://github.com/Rdatatable/data.table/issues/347). - - 17. `anyDuplicated.data.table` is now implemented. Closes [#350](https://github.com/Rdatatable/data.table/issues/350). Thanks to M C (bluemagister) for reporting. - - 18. Complex j-expressions of the form `DT[, c(..., lapply(.SD, fun)), by=grp]`are now optimised as long as `.SD` is of the form `lapply(.SD, fun)` or `.SD`, `.SD[1]` or `.SD[1L]`. This resolves [#370](https://github.com/Rdatatable/data.table/issues/370). Thanks to Sam Steingold for reporting. - This also completes the first two task lists in [#735](https://github.com/Rdatatable/data.table/issues/735). - ```R - ## example: - DT[, c(.I, lapply(.SD, sum), mean(x), lapply(.SD, log)), by=grp] - ## is optimised to - DT[, list(.I, x=sum(x), y=sum(y), ..., mean(x), log(x), log(y), ...), by=grp] - ## and now... these variations are also optimised internally for speed - DT[, c(..., .SD, lapply(.SD, sum), ...), by=grp] - DT[, c(..., .SD[1], lapply(.SD, sum), ...), by=grp] - DT[, .SD, by=grp] - DT[, c(.SD), by=grp] - DT[, .SD[1], by=grp] # Note: but not yet DT[, .SD[1,], by=grp] - DT[, c(.SD[1]), by=grp] - DT[, head(.SD, 1), by=grp] # Note: but not yet DT[, head(.SD, -1), by=grp] - # but not yet optimised - DT[, c(.SD[a], .SD[x>1], lapply(.SD, sum)), by=grp] # where 'a' is, say, a numeric or a data.table, and also for expressions like x>1 - ``` - The underlying message is that `.SD` is being slowly optimised internally wherever possible, for speed, without compromising in the nice readable syntax it provides. - - 19. `setDT` gains `keep.rownames = TRUE/FALSE` argument, which works only on `data.frame`s. TRUE retains the data.frame's row names as a new column named `rn`. - - 20. The output of `tables()` now includes `NCOL`. Thanks to @dnlbrky for the suggestion. - - 21. `DT[, LHS := RHS]` (or its equivalent in `set`) now provides a warning and returns `DT` as it was, instead of an error, when `length(LHS) = 0L`, [#343](https://github.com/Rdatatable/data.table/issues/343). For example: - ```R - DT[, grep(""^b"", names(DT)) := NULL] # where no columns start with b - # warns now and returns DT instead of error - ``` - - 22. GForce now is also optimised for j-expression with `.N`. Closes [#334](https://github.com/Rdatatable/data.table/issues/334) and part of [#523](https://github.com/Rdatatable/data.table/issues/523). - ```R - DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.2 - doesn't know to use GForce - will be (relatively) slower - DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.3+ - will use GForce. - ``` - - 23. `setDF` is now implemented. It accepts a data.table and converts it to data.frame by reference, [#338](https://github.com/Rdatatable/data.table/issues/338). Thanks to canneff for the discussion on data.table mailing list. - - 24. `.I` gets named as `I` (instead of `.I`) wherever possible, similar to `.N`, [#344](https://github.com/Rdatatable/data.table/issues/344). - - 25. `setkey` on `.SD` is now an error, rather than warnings for each group about rebuilding the key. The new error is similar to when attempting to use `:=` in a `.SD` subquery: `"".SD is locked. Using set*() functions on .SD is reserved for possible future use; a tortuously flexible way to modify the original data by group.""` Thanks to Ron Hylton for highlighting the issue on datatable-help. - - 26. Looping calls to `unique(DT)` such as in `DT[,unique(.SD),by=group]` is now faster by avoiding internal overhead of calling `[.data.table`. Thanks again to Ron Hylton for highlighting on datatable-help. His example is reduced from 28 sec to 9 sec, with identical results. - ---- - -# NB: methods _has_ to be attached before data.table in order for methods::as() to -# find the right dispatch when trying as(x, ""IDate""). This might be an R bug, but -# even running library(methods, pos=""package:base"") after attaching data.table doesn't work. -library(methods) -library(data.table) -test.data.table(script=""S4.Rraw"") - ---- - -You may also want to use just a subset of `data.table` functions; for example, some packages may simply make use of `data.table`'s high-performance CSV reader and writer, for which you can add `importFrom(data.table, fread, fwrite)` in your `NAMESPACE` file. It is also possible to import all functions from a package _excluding_ particular ones using `import(data.table, except=c(fread, fwrite))`. - -Be sure to read also the note about non-standard evaluation in `data.table` in [the section on ""undefined globals""](#globals). - -## Usage - -As an example we will define two functions in `a.pkg` package that uses `data.table`. One function, `gen`, will generate a simple `data.table`; another, `aggr`, will do a simple aggregation of it. - -```r -gen = function (n = 100L) { - dt = as.data.table(list(id = seq_len(n))) - dt[, grp := ((id - 1) %% 26) + 1 - ][, grp := letters[grp] - ][] -} -aggr = function (x) { - stopifnot( - is.data.table(x), - ""grp"" %in% names(x) - ) - x[, .N, by = grp] -} -``` - -## Testing - -Be sure to include tests in your package. Before each major release of `data.table`, we check reverse dependencies. This means that if any changes in `data.table` would break your code, we will be able to spot breaking changes and inform you before releasing the new version. This of course assumes you will publish your package to CRAN or Bioconductor. The most basic test can be a plaintext R script in your package directory `tests/test.R`: - -```r -library(a.pkg) -dt = gen() -stopifnot(nrow(dt) == 100) -dt2 = aggr(dt) -stopifnot(nrow(dt2) < 100) -``` - -When testing your package, you may want to use `R CMD check --no-stop-on-test-error`, which will continue after an error and run all your tests (as opposed to stopping on the first line of script that failed). - -## Testing using `testthat` - -It is very common to use the `testthat` package for purpose of tests. Testing a package that imports `data.table` is no different from testing other packages. An example test script `tests/testthat/test-pkg.R`: - -```r -context(""pkg tests"") - -test_that(""generate dt"", { expect_true(nrow(gen()) == 100) }) -test_that(""aggregate dt"", { expect_true(nrow(aggr(gen())) < 100) }) -``` - -If `data.table` is in Suggests (but not Imports) then you need to declare `.datatable.aware=TRUE` in one of the R/* files to avoid ""object not found"" errors when testing via `testthat::test_package` or `testthat::test_check`. - -## Dealing with ""undefined global functions or variables"" {#globals} - -`data.table`'s use of R's deferred evaluation (especially on the left-hand side of `:=`) is not well-recognised by `R CMD check`. This results in `NOTE`s like the following during package check: - -``` -* checking R code for possible problems ... NOTE -aggr: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'id' -Undefined global functions or variables: -grp id -``` - -The easiest way to deal with this is to pre-define those variables within your package and set them to `NULL`, optionally adding a comment (as is done in the refined version of `gen` below). When possible, you could also use a character vector instead of symbols (as in `aggr` below): - -```r -gen = function (n = 100L) { - id = grp = NULL # due to NSE notes in R CMD check - dt = as.data.table(list(id = seq_len(n))) - dt[, grp := ((id - 1) %% 26) + 1 - ][, grp := letters[grp] - ][] -} -aggr = function (x) { - stopifnot( - is.data.table(x), - ""grp"" %in% names(x) - ) - x[, .N, by = ""grp""] -} -``` - ---- - -#: onAttach.R:26 -#, c-format -msgid ""Latest news: r-datatable.com"" -msgstr ""Últimas novedades: r-datatable.com"" - -#: onAttach.R:27 -msgid ""TRANSLATION CHECK"" -msgstr ""VERIFICACIÓN DE TRADUCCIÓN"" - -#: onAttach.R:29 -#, c-format -msgid """" -""**********\n"" -""Running data.table in English; package support is available in English only. "" -""When searching for online help, be sure to also check for the English error "" -""message. This can be obtained by looking at the po/R-.po and po/"" -"".po files in the package source, where the native language and "" -""English error messages can be found side-by-side.%s\n"" -""**********"" -msgstr """" -""**********\n"" -""Ejecutando data.table en Español. El soporte del paquete está disponible "" -""solo en inglés. Cuando busque ayuda en línea, asegúrese de comprobar también "" -""el mensaje de error en inglés, examinando los archivos po/R-.po y po/"" -"".po en el código fuente del paquete. Allí se encuentran los mensajes "" -""de error en el idioma nativo y en inglés uno al lado del otro.%s\n"" -""**********"" - -#: onAttach.R:30 -msgid """" -""You can also try calling Sys.setLanguage('en') prior to reproducing the "" -""error message."" -msgstr """" -""Puede intentar llamar Sys.setLanguage('en') antes de reproducir el mensaje "" -""de error."" - -#: onAttach.R:34 -#, c-format -msgid """" -""**********\n"" -""This development version of data.table was built more than 4 weeks ago. "" -""Please update: data.table::update_dev_pkg()\n"" -""**********"" -msgstr """" -""**********\n"" -""Esta versión de desarrollo de data.table se creó hace más de 4 semanas. "" -""Actualice: data.table::update_dev_pkg()\n"" -""**********"" - -#: onAttach.R:36 -#, c-format -msgid """" -""**********\n"" -""This installation of data.table has not detected OpenMP support. It should "" -""still work but in single-threaded mode."" -msgstr """" -""************\n"" -""Esta instalación de data.table no ha detectado compatibilidad con OpenMP. "" -""Aún debería funcionar pero en modo de un solo hilo."" - -#: onAttach.R:38 -#, c-format -msgid """" -""This is a Mac. Please read https://mac.r-project.org/openmp/. Please engage "" -""with Apple and ask them for support. Check r-datatable.com for updates, and "" -""our Mac instructions here: https://github.com/Rdatatable/data.table/wiki/"" -""Installation. After several years of many reports of installation problems "" -""on Mac, it's time to gingerly point out that there have been no similar "" -""problems on Windows or Linux.\n"" -""**********"" -msgstr """" -""Esta es una Mac. Lea https://mac.r-project.org/openmp/. Comuníquese con "" -""Apple y pídales ayuda. Consulte r-datatable.com para obtener actualizaciones "" -""y nuestras instrucciones para Mac aquí: https://github.com/Rdatatable/data."" -""table/wiki/Installation. Después de varios años de muchos informes de "" -""problemas de instalación en Mac, es hora de señalar con cautela que no ha "" -""habido problemas similares en Windows o Linux.\n"" -""**********"" - -#: onAttach.R:40 -#, c-format -msgid """" -""This is %s. This warning should not normally occur on Windows or Linux where "" -""OpenMP is turned on by data.table's configure script by passing -fopenmp to "" -""the compiler. If you see this warning on Windows or Linux, please file a "" -""GitHub issue.\n"" -""**********"" -msgstr """" -""Esto es %s. Esta advertencia normalmente no debería aparecer en Windows o "" -""Linux donde OpenMP se activa mediante el script de configuración de data."" -""table pasando -fopenmp al compilador. Si ve esta advertencia en Windows o "" -""Linux, presente un problema en GitHub.\n"" -""**********"" - -#: onLoad.R:5 -#, c-format -msgid """" -""Option 'datatable.nomatch' is defined but is now ignored. Please see note 11 "" -""in v1.12.4 NEWS (Oct 2019), and note 14 in v1.14.2."" -msgstr """" -""La opción 'datatable.nomatch' está definida pero ahora se ignora. Consulte "" -""la nota 11 en v1.12.4 NEWS (octubre de 2019) y la nota 14 en v1.14.2."" - ---- - -Running comparative performance benchmarks to portray the relative efficiency of operations, i.e., in contrast to other packages that achieve similar functionality as data.table. - -Writing open-source material like blog posts to document such (with code to run the benchmarks provisioned therein), as they would tend to be a great resource for the community. Examples: df-atime-figures, df-partial-match - -Designing test scenarios to measure performance, such as handling large datasets, performing complex queries, having concurrent operations, etc. - -Staying informed with the latest developments in R programming and performance testing methodologies to bring such updates to data.table. - ---- - -selfrefok = function(DT,verbose=getOption(""datatable.verbose"")) { - .Call(Cselfrefokwrapper,DT,verbose) -} - -truelength = function(x) .Call(Ctruelength,x) -# deliberately no ""truelength<-"" method. setalloccol is the mechanism for that. -# settruelength() no longer need (and so removed) now that data.table depends on R 2.14.0 -# which initializes tl to zero rather than leaving uninitialized. - -setattr = function(x,name,value) { - # Wrapper for setAttrib internal R function - # Sets attribute by reference (no copy) - # Named setattr (rather than setattrib) at R level to more closely resemble attr<- - # And as from 1.7.8 is made exported in NAMESPACE for use in user attributes. - # User can also call `attr<-` function directly, but that copies (maybe just when NAMED>0, which is always for data.frame, I think). See ""Confused by NAMED"" thread on r-devel 24 Nov 2011. - # We tend to use setattr() internally in data.table.R because often we construct a data.table and it hasn't - # got names yet. setnames() is the user interface which checks integrity and doesn't let you drop names for example. - if (name==""names"" && is.data.table(x) && length(attr(x, ""names"", exact=TRUE)) && !is.null(value)) - setnames(x,value) - # Using setnames here so that truelength of names can be retained, to carry out integrity checks such as not - # creating names longer than the number of columns of x, and to change the key, too - # For convenience so that setattr(DT,""names"",allnames) works as expected without requiring a switch to setnames. - else { - ans = .Call(Csetattrib, x, name, value) - # If name==""names"" and this is the first time names are assigned (e.g. in data.table()), this will be grown by setalloccol very shortly afterwards in the caller. - if (!is.null(ans)) { - warningf(""Input is a length=1 logical that points to the same address as R's global value. Therefore the attribute has not been set by reference, rather on a copy. You will need to assign the result back to a variable. See issue #1281."") - x = ans - } - } - # fix for #1142 - duplicated levels for factors - if (name == ""levels"" && is.factor(x) && anyDuplicated(value)) - .Call(Csetlevels, x, (value <- as.character(value)), unique(value)) - invisible(x) -} - ---- - -3. `DT[col > val, head(.SD, 1), by = ...]` - объединяет `i` с `j` и - `by`. - -#### Также не забывайте: - -Если `j` возвращает `list`, каждый элемент этого списка станет столбцом в -результирующей `data.table`. - -В [следующем руководстве (`vignette(""datatable-reference-semantics"", -package=""data.table"")`)](../datatable-reference-semantics.html) мы -рассмотрим, как *добавлять/обновлять/удалять* столбцы *по ссылке* и как -комбинировать эти операции с `i` и `by`. - -*** - -```{r, echo=FALSE} -setDTthreads(.old.th) -``` - ---- - -Rolling Joins Robert Norberg 2016.05 From a (set.)seed grows a mighty dataset Jonathan Carroll 2016.05 Feather: fast, interoperable data import/export for R David Smith 2016.05 Best packages for data manipulation in R Fisseha Berhane 2016.05 My Two favorite Packages for Data Manipulation in R Fisseha Berhane 2016.05 Use H2O and data.table to build models on large data sets in R Manish Saraswat 2016.05 The R Data I/O Shootout Eduardo Ariño de la Rubia 2016.05 Red herring bites Matt Dowle 2016.05 data.table() vs data.frame() – Learn to work on large data sets in R Manish Saraswat 2016.04 Feather: it's about metadata Wes McKinney 2016.04 Fast csv writing for R Matt Dowle 2016.04 I'll Keep Using R Michael Ekstrand 2016.04 data.table objects should not be considered data.frame instances in R [retracted] John Mount 2016.04 Learning R in Seven Simple Steps Martijn Theuwissen 2016.04 Collapsing lists of data.frames with data.table Steph Locke 2016.04 Working with databases in R Fisseha Berhane 2016.03 Data table exercises: keys and subsetting Han de Vries 2016.03 Performing SQL selects on R data frames Fisseha Berhane 2016.02 Read from hdfs with R. Brief overview of SparkR Dmitriy Selivanov 2016.02 Up to code? An algorithm is helping Chicago health officials predict restaurant safety violations (featured on TV at 06:40 ). [ Tweet ] [ Code ] PBS NewsHour 2016.01 Strategies to Speedup R Code Selva Prabhakaran 2015.12 Our R package roundup 2015 Christoph Safferling 2015.12 Who’s downloading the forecast package? Rob J Hyndman 2015.12 Solve common R problems efficiently with data.table Jan Gorecki 2015.11 Efficient aggregation (and more) using data.table David Kun 2015.11 Scaling data.table with index Jan Gorecki 2015.11 H2O World 2015 – Day 2 Highlights Anmol Rajpurohit, KDnuggets 2015.11 H2O World 2015 Joseph Rickert 2015.11 H2O.ai raises $20m series B to capitalize on rapid open source machine-learning growth Matt Aslett, 451 Research 2015.10 R and Impala: it's better to KISS than using Java Gergely Daroczi 2015.10 R: data.table – Finding the maximum row Mark Needham 2015.09 Querying a 20 million line CSV file – data.table vs data frame Mark Needham 2015.09 Data ergonomics with data.table, iHub Nairobi, with supporting materials Henk Harmsen 2015.09 R Stories from the Trenches [ Video ] [ Slides ] Szilard Pafka 2015.09 Advanced Tips and Tricks with data.table Andrew Brooks 2015.08 data.table cookbook Steph Locke 2015.07 Overlap joins in R: a speed comparison with packages sqldf and data.table Zev Ross 2015.06 Data Warehousing with R Jan Gorecki 2015.06 Auditing data transformation Jan Gorecki 2015.06 Back from R/Finance in Chicago Markus Gesmann 2015.05 Fast data munging in R Alexander Konduforov 2015.05 No THIS Is How You dplyr and data.table! Jeffrey Horner 2015.05 Comparing data frames, data.table and dplyr with random walks David Smith 2015.05 Working with ""large"" datasets, with dplyr and data.table Arthur Charpentier 2015.04 Comparing the execution time between foverlaps and findOverlaps [data.table vs GenomicRanges] Katarzyna Wręczycka 2015.04 Open Source Business Intelligence: Then and Now Steve Miller 2015.04 Mapping Flows in R with data.table and lattice Oscar Perpiñán Lamigueiro 2015.03 Need for Processing Speed: data.table OpenAnalytics 2015.03 Getting Data From An Online Source Robert Norberg 2015.02 A data.table R tutorial by DataCamp: intro to DT[i, j, by] DataCamp 2015.02 Minimal example for joining data.tables Markus Gesmann 2015.01 Using the microbenchmark package to compare the execution time of R expressions Stephen Turner 2015.01 Sessionizing Log Data Using data.table Randy Zwitch 2015.01 R in Business Intelligence Jan Gorecki 2014.12 dplyr and a very basic benchmark Szilard Pafka 2014.12 JOINing data in R using data.table Ronald Stalder 2014.12 Cheat Sheets for Data Science Steve Miller 2014.11 Partying R Style with Sqor Sports, R on Azure, and data.table Joseph Rickert 2014.11 The data.table Cheat Sheet DataCamp - ---- - -require(data.table) -test.data.table(script=""programming.Rraw"") - ---- - -R Under development (unstable) (2024-12-01 r87412) -- ""Unsuffered Consequences"" -Copyright (C) 2024 The R Foundation for Statistical Computing -Platform: x86_64-pc-linux-gnu - -R is free software and comes with ABSOLUTELY NO WARRANTY. -You are welcome to redistribute it under certain conditions. -Type 'license()' or 'licence()' for distribution details. - -R is a collaborative project with many contributors. -Type 'contributors()' for more information and -'citation()' on how to cite R or R packages in publications. - -Type 'demo()' for some demos, 'help()' for on-line help, or -'help.start()' for an HTML browser interface to help. -Type 'q()' to quit R. - ---- - ---- -title: ""Importing data.table"" -date: ""`{r} Sys.Date()`"" -output: - litedown::html_format -vignette: > - %\VignetteIndexEntry{Importing data.table} - %\VignetteEngine{litedown::vignette} - \usepackage[utf8]{inputenc} ---- - -```{r, echo = FALSE, message = FALSE} -litedown::reactor(comment = ""# "") -.old.th = data.table::setDTthreads(1) -``` - - - -```{r, echo=FALSE, file='_translation_links.R'} -``` -`{r} .write.translation.links(""Translations of this document are available in: %s"")` - -This document is focused on using `data.table` as a dependency in other R packages. If you are interested in using `data.table` C code from a non-R application, or in calling its C functions directly, jump to the [last section](#non-r-api) of this vignette. - -Importing `data.table` is no different from importing other R packages. This vignette is meant to answer the most common questions arising around that subject; the lessons presented here can be applied to other R packages. - -## Why to import `data.table` - -One of the biggest features of `data.table` is its concise syntax which makes exploratory analysis faster and easier to write and perceive; this convenience can drive package authors to use `data.table`. Another, perhaps more important reason is high performance. When outsourcing heavy computing tasks from your package to `data.table`, you usually get top performance without needing to re-invent any of these numerical optimization tricks on your own. - -## Importing `data.table` is easy - -It is very easy to use `data.table` as a dependency due to the fact that `data.table` does not have any of its own dependencies. This applies both to operating system and to R dependencies. It means that if you have R installed on your machine, it already has everything needed to install `data.table`. It also means that adding `data.table` as a dependency of your package will not result in a chain of other recursive dependencies to install, making it very convenient for offline installation. - -## `DESCRIPTION` file {#DESCRIPTION} - -The first place to define a dependency in a package is the `DESCRIPTION` file. Most commonly, you will need to add `data.table` under the `Imports:` field. Doing so will necessitate an installation of `data.table` before your package can compile/install. As mentioned above, no other packages will be installed because `data.table` does not have any dependencies of its own. You can also specify the minimal required version of a dependency; for example, if your package is using the `fwrite` function, which was introduced in `data.table` in version 1.9.8, you should incorporate this as `Imports: data.table (>= 1.9.8)`. This way you can ensure that the version of `data.table` installed is 1.9.8 or later before your users will be able to install your package. Besides the `Imports:` field, you can also use `Depends: data.table` but we strongly discourage this approach (and may disallow it in future) because this loads `data.table` into your user's workspace; i.e. it enables `data.table` functionality in your user's scripts without them requesting that. `Imports:` is the proper way to use `data.table` within your package without inflicting `data.table` on your user. In fact, we hope the `Depends:` field is eventually deprecated in R since this is true for all packages. - -## `NAMESPACE` file {#NAMESPACE} - -The next thing is to define what content of `data.table` your package is using. This needs to be done in the `NAMESPACE` file. Most commonly, package authors will want to use `import(data.table)` which will import all exported (i.e., listed in `data.table`'s own `NAMESPACE` file) functions from `data.table`. - ---- - -#: data.table.R:139 -#, c-format -msgid ""Item '%s' not found in names of input list"" -msgstr ""Не могу найти «%s» среди имён входного списка"" - -#: data.table.R:159 -#, c-format -msgid """" -""[ was called on a data.table in an environment that is not data.table-aware "" -""(i.e. cedta()), but '%s' was used, implying the owner of this call really "" -""intended for data.table methods to be called. See vignette('datatable-"" -""importing') for details on properly importing data.table."" -msgstr """" -""Метод [ был вызван для data.table из окружения, не поддерживающего data."" -""table (см. ?cedta()), но было передано '%s', что означает, что вызывающей "" -""функции действительно нужен метод data.table. Подробнее о правильном "" -""использовании data.table в пакетах см. в vignette('datatable-importing')."" - -#: data.table.R:170 -#, c-format -msgid ""verbose must be logical or integer"" -msgstr ""«verbose» должно быть логическим или целочисленным"" - -#: data.table.R:171 -#, c-format -msgid ""verbose must be length 1 non-NA"" -msgstr ""«verbose» должно быть длины 1 и не-NA"" - -#: data.table.R:179 -#, c-format -msgid ""Ignoring by/keyby because 'j' is not supplied"" -msgstr ""Игнорирую «by»/«keyby», потому что «j» не был передан"" - -#: data.table.R:193 -#, c-format -msgid ""When by and keyby are both provided, keyby must be TRUE or FALSE"" -msgstr ""Когда «by» и «keyby» оба переданы, «keyby» должно быть TRUE либо FALSE"" - -#: data.table.R:196 data.table.R:261 data.table.R:351 -msgid ""Argument '%s' after substitute: %s"" -msgstr ""Аргумент «%s» после подстановки: %s"" - -#: data.table.R:205 -#, c-format -msgid """" -""When on= is provided but not i=, on= must be a named list or data.table|"" -""frame, and a natural join (i.e. join on common names) is invoked. Ignoring "" -""on= which is '%s'."" -msgstr """" -""Если указано on=, но не i=, on= должно быть именованным списком или data."" -""table|frame; тогда будет выполнено натуральное соединение (т. е. по столбцам "" -""с общими именами). Игнорирую on=, которое имеет значение '%s'."" - -#: data.table.R:218 -#, c-format -msgid """" -""i and j are both missing so ignoring the other arguments. This warning will "" -""be upgraded to error in future."" -msgstr """" -""i и j отсутствуют, поэтому игнорирую остальные аргументы. В будущем это "" -""предупреждение будет преобразовано в ошибку."" - -#: data.table.R:222 -#, c-format -msgid ""mult argument can only be 'first', 'last', 'all' or 'error'"" -msgstr ""аргумент «mult» должен быть 'first', 'last', 'all' или 'error'"" - -#: data.table.R:224 -#, c-format -msgid """" -""roll must be a single TRUE, FALSE, positive/negative integer/double "" -""including +Inf and -Inf or 'nearest'"" -msgstr """" -""roll должен быть TRUE, FALSE, положительным/отрицательным числом, включая "" -""+Inf и -Inf, либо 'nearest'"" - -#: data.table.R:226 -#, c-format -msgid ""roll is '%s' (type character). Only valid character value is 'nearest'."" -msgstr """" -""«roll» - это '%s' (строка). Единственное допустимое строковое значение - "" -""'nearest'."" - -#: data.table.R:231 -#, c-format -msgid ""rollends must be a logical vector"" -msgstr ""«rollends» должно быть логическим вектором"" - -#: data.table.R:232 -#, c-format -msgid ""rollends must be length 1 or 2"" -msgstr ""«rollends» должно быть длины 1 или 2"" - -#: data.table.R:240 -#, c-format -msgid """" -""nomatch= must be either NA or NULL (or 0 for backwards compatibility which "" -""is the same as NULL but please use NULL)"" -msgstr """" -""nomatch= должно быть либо NA, либо NULL (ранее 0 значило то же, что сейчас "" -""значит NULL)"" - -#: data.table.R:243 -#, c-format -msgid ""which= must be a logical vector length 1. Either FALSE, TRUE or NA."" -msgstr ""which= должен быть FALSE, TRUE или NA_logical_."" - -#: data.table.R:244 -#, c-format -msgid """" -""which==%s (meaning return row numbers) but j is also supplied. Either you "" -""need row numbers or the result of j, but only one type of result can be "" -""returned."" -msgstr """" -""which==%s (значит, вернуть номера строк), но также передан j. Вы можете "" -""запросить либо одно, либо другое, но не всё сразу."" - ---- - -### Étape 3 : Mettre à jour vos fichiers de code R en dehors du répertoire R/ du package - -Lorsque vous déplacez un package de `Depends` vers `Imports`, il ne sera plus automatiquement attaché lorsque votre package sera chargé. Cela peut être important pour les exemples, les tests, les vignettes et les démos, où les packages `Imports` doivent être attachés explicitement. - -**Avant (avec `Depends`) :** - -```r -# les fonctions de data.table sont directement disponibles -library(MyPkgDependsDataTable) -dt <- data.table(x = 1:10, y = letters[1:10]) -setDT(dt) -result <- merge(dt, other_dt, by = ""x"") -``` - -**Après (avec `Imports`) :** - -```r -# Charger explicitement data.table dans les scripts utilisateurs ou les vignettes -library(data.table) -library(MyPkgDependsDataTable) -dt <- data.table(x = 1:10, y = letters[1:10]) -setDT(dt) -result <- merge(dt, other_dt, by = ""x"") -``` - -### Avantages de l'utilisation de `Imports` - -- **Convivialité** : `Depends` modifie le chemin `search()` de vos utilisateurs, éventuellement sans qu'ils le veuillent. -- **Gestion de l'espace de noms** : Seules les fonctions que votre package importe explicitement sont disponibles, ce qui réduit le risque de conflit de noms de fonctions. -- **Chargement de package plus propre** : Les dépendances de votre package ne sont pas attachées au chemin de recherche, ce qui rend le processus de chargement plus propre et potentiellement plus rapide. -- **Maintenance plus facile** : Cela simplifie les tâches de maintenance au fur et à mesure que les API des dépendances en amont évoluent. Trop dépendre de `Depends` peut conduire à des conflits et des problèmes de compatibilité au fil du temps. - -```{r, echo = FALSE, message = FALSE} -data.table::setDTthreads(.old.th) -``` - ---- - -## fichier `NAMESPACE` {#NAMESPACE} - -La prochaine chose à faire est de définir le contenu de `data.table` que votre package utilise. Cela doit être fait dans le fichier `NAMESPACE`. Le plus souvent, les auteurs de package voudront utiliser `import(data.table)` qui importera toutes les fonctions exportées (c'est-à-dire listées dans le fichier `NAMESPACE` de `data.table`) de `data.table`. - -Vous pouvez aussi ne vouloir utiliser qu'un sous-ensemble des fonctions de `data.table` ; par exemple, certains packages peuvent simplement utiliser les fonctions d'écriture et lecture CSV haute performance de `data.table`, pour lesquelles vous pouvez ajouter `importFrom(data.table, fread, fwrite)` dans votre fichier `NAMESPACE`. Il est également possible d'importer toutes les fonctions d'un package *en excluant* certaines d'entre elles en utilisant `import(data.table, except=c(fread, fwrite))`. - -Assurez-vous de lire également la note sur l'évaluation non standard dans `data.table` dans [la section sur les ""globales non définies""](#globals) - -## Utilisation - -A titre d'exemple, nous allons définir deux fonctions dans le package `a.pkg` qui utilise `data.table`. Une fonction, `gen`, générera un simple `data.table` ; une autre, `aggr`, en fera une simple agrégation. - -```r -gen = function (n = 100L) { - dt = as.data.table(list(id = seq_len(n))) - dt[, grp := ((id - 1) %% 26) + 1 - ][, grp := letters[grp] - ][] -} -aggr = function (x) { - stopifnot( - is.data.table(x), - ""grp"" %in% names(x) - ) - x[, .N, by = grp] -} -``` - -## Tests - -Assurez-vous d'inclure des tests dans votre package. Avant chaque version majeure de `data.table`, nous vérifions les dépendances inverses. Cela signifie que si un changement dans `data.table` casse votre code, nous serons capables de repérer les changements et de vous en informer avant de publier la nouvelle version. Cela suppose bien sûr que vous publiiez votre package sur CRAN ou Bioconductor. Le test le plus basique peut être un script R en clair dans le répertoire `tests/test.R` de votre package : - -```r -library(a.pkg) -dt = gen() -stopifnot(nrow(dt) == 100) -dt2 = aggr(dt) -stopifnot(nrow(dt2) < 100) -``` - -Lorsque vous testez votre package, vous pouvez utiliser `R CMD check --no-stop-on-test-error`, qui continuera après une erreur et exécutera tous vos tests (au lieu de s'arrêter à la première ligne du script qui a échoué). - -## Tester en utilisant `testthat` - -Il est très courant d'utiliser le package `testthat` pour effectuer des tests. Tester un package qui importe `data.table` n'est pas différent de tester d'autres packages. Un exemple de script de test `tests/testthat/test-pkg.R` : - -```r -context(""pkg tests"") - -test_that(""generate dt"", { expect_true(nrow(gen()) == 100) }) -test_that(""aggregate dt"", { expect_true(nrow(aggr(gen())) < 100) }) -``` - -Si `data.table` est dans Suggests (mais pas dans Imports) alors vous devez déclarer `.datatable.aware=TRUE` dans un des fichiers R/* pour éviter les erreurs ""object not found"" lors des tests via `testthat::test_package` ou `testthat::test_check`. - -## Traitement des ""fonctions ou variables globales indéfinies"" (""undefined global functions or variables"") {#globals} - -l'utilisation par `data.table` de l'évaluation différée de R (en particulier sur le côté gauche de `:=`) n'est pas bien reconnue par `R CMD check`. Il en résulte des `NOTE`s comme la suivante lors de la vérification du package : - -``` -* checking R code for possible problems ... NOTE -aggr: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'id' -Undefined global functions or variables: -grp id -``` - ---- - -6. `.()` can now be used in `j` and is identical to `list()`, for consistency with `i`. - ```R - DT[,list(MySum=sum(B)),by=...] - DT[,.(MySum=sum(B)),by=...] # same - DT[,list(colB,colC,colD)] - DT[,.(colB,colC,colD)] # same - ``` - Similarly, `by=.()` is now a shortcut for `by=list()`, for consistency with `i` and `j`. - - 7. `rbindlist` gains `use.names` and `fill` arguments and is now implemented entirely in C. Closes [#345](https://github.com/Rdatatable/data.table/issues/345): - * `use.names` by default is FALSE for backwards compatibility (does not bind by names by default) - * `rbind(...)` now just calls `rbindlist()` internally, except that `use.names` is TRUE by default, for compatibility with base (and backwards compatibility). - * `fill=FALSE` by default. If `fill=TRUE`, `use.names` has to be TRUE. - * When use.names=TRUE, at least one item of the input list has to have non-null column names. - * When fill=TRUE, all items of the input list has to have non-null column names. - * Duplicate columns are bound in the order of occurrence, like base. - * Attributes that might exist in individual items would be lost in the bound result. - * Columns are coerced to the highest SEXPTYPE when they are different, if possible. - * And incredibly fast ;). - * Documentation updated in much detail. Closes [#333](https://github.com/Rdatatable/data.table/issues/333). - - 8. `bit64::integer64` now works in grouping and joins, [#342](https://github.com/Rdatatable/data.table/issues/342). Thanks to James Sams for highlighting UPCs and Clayton Stanley for [this SO post](https://stackoverflow.com/questions/22273321/large-integers-in-data-table-grouping-results-different-in-1-9-2-compared-to-1). `fread()` has been detecting and reading `integer64` for a while. - - 9. `setNumericRounding()` may be used to reduce to 1 byte or 0 byte rounding when joining to or grouping columns of type 'numeric', [#342](https://github.com/Rdatatable/data.table/issues/342). See example in `?setNumericRounding` and NEWS item below for v1.9.2. `getNumericRounding()` returns the current setting. - - 10. `X[Y]` now names non-join columns from `i` that have the same name as a column in `x`, with an `i.` prefix for consistency with the `i.` prefix that has been available in `j` for some time. This is now documented. - - 11. For a keyed table `X` where the key columns are not at the beginning in order, `X[Y]` now retains the original order of columns in X rather than moving the join columns to the beginning of the result. - - 12. It is no longer an error to assign to row 0 or row NA. - ```R - DT[0, colA := 1L] # now does nothing, silently (was error) - DT[NA, colA := 1L] # now does nothing, silently (was error) - DT[c(1, NA, 0, 2), colA:=1L] # now ignores the NA and 0 silently (was error) - DT[nrow(DT) + 1, colA := 1L] # error (out-of-range) as before - ``` - This is for convenience to avoid the need for a switch in user code that evals various `i` conditions in a loop passing in `i` as an integer vector which may containing `0` or `NA`. - - 13. A new function `setorder` is now implemented which uses data.table's internal fast order to reorder rows *by reference*. It returns the result invisibly (like `setkey`) that allows for compound statements; e.g., `setorder(DT, a, -b)[, cumsum(c), by=list(a,b)]`. Check `?setorder` for more info. - - 14. `DT[order(x, -y)]` is now by default optimised to use data.table's internal fast order as `DT[forder(DT, x, -y)]`. It can be turned off by setting `datatable.optimize` to < 1L or just calling `base:::order` explicitly. It results in 20x speedup on data.table of 10 million rows with 2 integer columns, for example. To order character vectors in descending order it's sufficient to do `DT[order(x, -y)]` as opposed to `DT[order(x, -xtfrm(y))]` in base. This closes [#603](https://github.com/Rdatatable/data.table/issues/603). - ---- - -dim.data.table = function(x) -{ - .Call(Cdim, x) -} - -.global = new.env() # thanks to: http://stackoverflow.com/a/12605694/403310 -methods::setPackageName(""data.table"",.global) -.global$print = """" - -# NB: if adding to/editing this list, be sure to do the following: -# (1) add to man/special-symbols.Rd -# (2) export() in NAMESPACE -# (3) add to vignettes/datatable-importing.Rmd#globals section -.SD = .N = .I = .GRP = .NGRP = .BY = .EACHI = NULL -# These are exported to prevent NOTEs from R CMD check, and checkUsage via compiler. -# But also exporting them makes it clear (to users and other packages) that data.table uses these as symbols. -# And NULL makes it clear (to the R's mask check on loading) that they're variables not functions. -# utils::globalVariables(c("".SD"","".N"")) was tried as well, but exporting seems better. -# So even though .BY doesn't appear in this file, it should still be NULL here and exported because it's -# defined in SDenv and can be used by users. - -is.data.table = function(x) inherits(x, ""data.table"") -is.ff = function(x) inherits(x, ""ff"") # define this in data.table so that we don't have to require(ff), but if user is using ff we'd like it to work - -#NCOL = function(x) { -# # copied from base, but additionally covers data.table via is.list() -# # because NCOL in base explicitly tests using is.data.frame() -# if (is.list(x) && !is.ff(x)) return(length(x)) -# if (is.array(x) && length(dim(x)) > 1L) ncol(x) else as.integer(1L) -#} -#NROW = function(x) { -# if (is.data.frame(x) || is.data.table(x)) return(nrow(x)) -# if (is.list(x) && !is.ff(x)) stopf(""List is not a data.frame or data.table. Convert first before using NROW"") # list may have different length elements, which data.table and data.frame's resolve. -# if (is.array(x)) nrow(x) else length(x) -#} - -null.data.table = function() { - ans = list() - setattr(ans,""class"",c(""data.table"",""data.frame"")) - setattr(ans,""row.names"",.set_row_names(0L)) - setalloccol(ans) -} - -data.table = function(..., keep.rownames=FALSE, check.names=FALSE, key=NULL, stringsAsFactors=FALSE) -{ - # NOTE: It may be faster in some circumstances for users to create a data.table by creating a list l - # first, and then setattr(l,""class"",c(""data.table"",""data.frame"")) and forgo checking. - x = list(...) # list() doesn't copy named inputs as from R >= 3.1.0 (a very welcome change) - nd = name_dots(...) - names(x) = nd$vnames - if (length(x)==0L) return( null.data.table() ) - if (length(x)==1L && (is.null(x[[1L]]) || (is.list(x[[1L]]) && length(x[[1L]])==0L))) return( null.data.table() ) #48 - ans = as.data.table.list(x, keep.rownames=keep.rownames, check.names=check.names, .named=nd$.named) # see comments inside as.data.table.list re copies - if (!is.null(key)) { - if (!is.character(key)) stopf(""key argument of data.table() must be character"") - if (length(key)==1L) key = cols_from_csv(key) - setkeyv(ans,key) - } else { - # retain key of cbind(DT1, DT2, DT3) where DT2 is keyed but not DT1. cbind calls data.table(). - # If DT inputs with keys have been recycled then can't retain key - ckey = NULL - for (i in seq_along(x)) { - xi = x[[i]] - if (is.data.table(xi) && haskey(xi) && nrow(xi)==nrow(ans)) ckey=c(ckey, key(xi)) - } - if (length(ckey) && - !anyDuplicated(ckey) && - identical(is.na(chmatchdup(c(ckey,ckey), names(ans))), rep(c(FALSE,TRUE),each=length(ckey)))) { - setattr(ans, ""sorted"", ckey) - } - } - if (isTRUE(stringsAsFactors)) { - for (j in which(vapply_1b(ans, is.character))) set(ans, NULL, j, as_factor(.subset2(ans, j))) - # as_factor is internal function in fread.R currently - } - setalloccol(ans) # returns a NAMED==0 object, unlike data.frame() -} - ---- - -El caso de los símbolos especiales de `data.table` (p. ej., `.SD` y `.N`) y el operador de asignación (`:=`) es ligeramente diferente (consulte `?.N` para obtener más información, incluyendo una lista completa de dichos símbolos). Debe importar cualquiera de estos valores que utilice del espacio de nombres de `data.table` para evitar problemas derivados del improbable escenario de que cambiemos el valor exportado de estos en el futuro. Por ejemplo, si desea usar `.N`, `.I` y `:=`, un `NAMESPACE` mínimo tendría: - -```r -importFrom(data.table, .N, .I, ':=') -``` - -Mucho más simple es simplemente usar `import(data.table)`, lo que permitirá el uso en el código de su paquete de cualquier objeto exportado desde `data.table`. - -Si no le importa tener `id` y `grp` registrados como variables globales en el espacio de nombres de su paquete, puede usar `?globalVariables`. Tenga en cuenta que estas notas no afectan el código ni su funcionalidad; si no va a publicar su paquete, puede simplemente ignorarlas. - -## Se debe tener cuidado al proporcionar y utilizar `options` - -Una práctica común en los paquetes de R es proporcionar opciones de personalización definidas por `options(name=val)` y obtenidas mediante `getOption(""name"", default)`. Los argumentos de función suelen especificar una llamada a `getOption()` para que el usuario conozca (a través de `?fun` o `args(fun)`) el nombre de la opción que controla el valor predeterminado para ese parámetro; por ejemplo, `fun(..., verbose=getOption(""datatable.verbose"", FALSE))`. Todas las opciones de `data.table` comienzan con `datatable.` para evitar conflictos con las opciones de otros paquetes. El usuario simplemente llama a `options(datatable.verbose=TRUE)` para activar la verbosidad. Esto afecta a todas las llamadas a la función data.table, a menos que `verbose=FALSE` se especifique explícitamente; por ejemplo, `fun(..., verbose=FALSE)`. - -El mecanismo de opciones en R es *global*. Esto significa que si un usuario establece una opción `data.table` para su propio uso, esa configuración también afecta al código dentro de cualquier paquete que también esté usando `data.table`. Para una opción como `datatable.verbose`, este es exactamente el comportamiento deseado ya que el deseo es rastrear y registrar todas las operaciones de `data.table` desde donde sea que se originen; activar la verbosidad no afecta los resultados. Otra opción única de R y excelente para producción es `options(warn=2)` de R que convierte todas las advertencias en errores. Nuevamente, el deseo es afectar cualquier advertencia en cualquier paquete para no perder ninguna advertencia en producción. Hay 6 opciones `datatable.print.*` y 3 opciones de optimización que no afectan el resultado de las operaciones. Sin embargo, hay una opción `data.table` que sí afecta y ahora es una preocupación: `datatable.nomatch`. Esta opción cambia la unión predeterminada de externa a interna. [Aparte, la unión predeterminada es externa porque externa es más segura; no elimina los datos faltantes silenciosamente; Además, es coherente con el método R básico para la coincidencia por nombres e índices. Algunos usuarios prefieren que la unión interna sea la opción predeterminada, y les proporcionamos esta opción. Sin embargo, si un usuario configura esta opción, puede cambiar involuntariamente el comportamiento de las uniones dentro de paquetes que usan `data.table`. Por consiguiente, en la versión 1.12.4 (octubre de 2019) se mostraba un mensaje al usar la opción `datatable.nomatch`, y a partir de la versión 1.14.2, se ignora con una advertencia. Era la única opción de `data.table` con este problema. - -## Solución de problemas - -Si enfrenta algún problema al crear un paquete que usa data.table, confirme que el problema se pueda reproducir en una sesión R limpia usando la consola R: `R CMD check package.name`. - ---- - -## Où sont les archives de datatable-help ? - -La [page d'accueil](https://github.com/Rdatatable/data.table/wiki) contient des liens vers les archives en plusieurs formats. - -## Je préférerais ne pas publier sur la page ""Questions"" (Issues). Puis-je envoyer un email à une ou deux personnes ? - -Bien sûr, mais il est plus probable que vous obteniez une réponse plus rapide sur la page Issues ou sur Stack Overflow. De plus, le fait de poser des questions publiquement à ces endroits aide à construire la base de connaissances générale. - -## J'ai créé un package qui utilise data.table. Comment puis-je m'assurer que mon package est compatible avec data.table pour que l'héritage de `data.frame` fonctionne ? - -Voir [cette réponse](https://stackoverflow.com/a/10529888/403310). - -```{r, echo=FALSE} -setDTthreads(.old.th) -``` - ---- - -#include ""data.table.h"" -#include - -// Wrappers for R internal functions. We can't rely on calling -// Rf_setAttrib and Rf_duplicate directly from .Call in R on -// all platforms, as we found out when v1.6.5 went to CRAN on -// 25 Aug 2011, see Professor Ripley's response that day. - -SEXP setattrib(SEXP x, SEXP name, SEXP value) -{ - if (!isString(name) || LENGTH(name)!=1) error(_(""Attribute name must be a character vector of length 1"")); - if (!isNewList(x) && - strcmp(CHAR(STRING_ELT(name,0)),""class"")==0 && - isString(value) && LENGTH(value)>0 && - (strcmp(CHAR(STRING_ELT(value, 0)),""data.table"")==0 || strcmp(CHAR(STRING_ELT(value,0)),""data.frame"")==0) ) { - error(_(""Internal structure doesn't seem to be a list. Can't set class to be 'data.table' or 'data.frame'. Use 'as.data.table()' or 'as.data.frame()' methods instead."")); - } - if (isLogical(x) && LENGTH(x)==1 && - (x==ScalarLogical(TRUE) || x==ScalarLogical(FALSE) || x==ScalarLogical(NA_LOGICAL))) { // R's internal globals, #1281 - x = PROTECT(duplicate(x)); - setAttrib(x, name, MAYBE_REFERENCED(value) ? duplicate(value) : value); - UNPROTECT(1); - return(x); - } - if (isNull(value) && isPairList(x) && strcmp(CHAR(STRING_ELT(name,0)),""names"")==0) { - // backport fix in R 3.2.0 to support R 3.1.0; #4048 #3802 - // apply this backport always (i.e. in R >=3.2.0 too) to avoid a switch on version number or feature test (to avoid more code, tests and nocov) - for (SEXP t=x; t!=R_NilValue; t=CDR(t)) { - SET_TAG(t, R_NilValue); - } - } else { - setAttrib(x, name, MAYBE_REFERENCED(value) ? duplicate(value) : value); - // duplicate is temp fix to restore R behaviour prior to R-devel change on 10 Jan 2014 (r64724). - // TO DO: revisit. Enough to reproduce is: DT=data.table(a=1:3); DT[2]; DT[,b:=2] - // ... Error: selfrefnames is ok but tl names [1] != tl [100] - } - return(R_NilValue); -} - -// fix for #1142 - duplicated levels for factors -SEXP setlevels(SEXP x, SEXP levels, SEXP ulevels) { - - R_len_t nx = length(x); - SEXP xchar, newx; - xchar = PROTECT(allocVector(STRSXP, nx)); - int *ix = INTEGER(x); - const int nlevels = length(levels); - for (int i=0; i= 1 && ixi <= nlevels) ? STRING_ELT(levels, ix[i]-1) : NA_STRING); - } - newx = PROTECT(chmatch(xchar, ulevels, NA_INTEGER)); - const int *inewx = INTEGER_RO(newx); - for (int i=0; i3, .(ITEM='A>3', A, B)] # (1) - DT[A>3][, .(ITEM='A>3', A, B)] # (2) - # the above are now equivalent as expected and return: - Empty data.table (0 rows and 3 cols): ITEM,A,B - # Previously, (2) returned : - ITEM A B - - 1: A>3 NA - Warning messages: - 1: In as.data.table.list(jval, .named = NULL) : - Item 2 has 0 rows but longest item has 1; filled with NA - 2: In as.data.table.list(jval, .named = NULL) : - Item 3 has 0 rows but longest item has 1; filled with NA - ``` - - ```R - DT = data.table(A=1:3, B=letters[1:3], key=""A"") - DT[.(1:3, double()), B] - # new result : - character(0) - # old result : - [1] ""a"" ""b"" ""c"" - Warning message: - In as.data.table.list(i) : - Item 2 has 0 rows but longest item has 3; filled with NA - ``` - -5. `%like%` on factors with a large number of levels is now faster, [#4748](https://github.com/Rdatatable/data.table/issues/4748). The example in the PR shows 2.37s reduced to 0.86s on a factor length 100 million containing 1 million unique 10-character strings. Thanks to @statquant for reporting, and @shrektan for implementing. - -6. `keyby=` now accepts `TRUE`/`FALSE` together with `by=`, [#4307](https://github.com/Rdatatable/data.table/issues/4307). The primary motivation is benchmarking where `by=` vs `keyby=` is varied across a set of queries. Thanks to Jan Gorecki for the request and the PR. - - ```R - DT[, sum(colB), keyby=""colA""] - DT[, sum(colB), by=""colA"", keyby=TRUE] # same - ``` - -7. `fwrite()` gains a new `datatable.fwrite.sep` option to change the default separator, still `"",""` by default. Thanks to Tony Fischetti for the PR. As is good practice in R in general, we usually resist new global options for the reason that a user changing the option for their own code can inadvertently change the behaviour of any package using `data.table` too. However, in this case, the global option affects file output rather than code behaviour. In fact, the very reason the user may wish to change the default separator is that they know a different separator is more appropriate for their data being passed to the package using `fwrite` but cannot otherwise change the `fwrite` call within that package. - -8. `melt()` now supports `NA` entries when specifying a list of `measure.vars`, which translate into runs of missing values in the output. Useful for melting wide data with some missing columns, [#4027](https://github.com/Rdatatable/data.table/issues/4027). Thanks to @vspinu for reporting, and @tdhock for implementing. - ---- - -Historical note: \code{melt.data.table} was originally designed as an enhancement to \code{reshape2::melt} in terms of computing and memory efficiency. \code{reshape2} has since been superseded in favour of \code{tidyr}, and \code{melt} has had a generic defined within \code{data.table} since \code{v1.9.6} in 2015, at which point the dependency between the packages became more etymological than programmatic. We thank the \code{reshape2} authors for the inspiration. - -} - -\value{ -An unkeyed \code{data.table} containing the molten data. -} - -\examples{ -set.seed(45) -require(data.table) -DT <- data.table( - i_1 = c(1:5, NA), - n_1 = c(NA, 6, 7, 8, 9, 10), - f_1 = factor(sample(c(letters[1:3], NA), 6L, TRUE)), - f_2 = factor(c(""z"", ""a"", ""x"", ""c"", ""x"", ""x""), ordered=TRUE), - c_1 = sample(c(letters[1:3], NA), 6L, TRUE), - c_2 = sample(c(LETTERS[1:2], NA), 6L, TRUE), - d_1 = as.Date(c(1:3,NA,4:5), origin=""2013-09-01""), - d_2 = as.Date(6:1, origin=""2012-01-01"") -) -# add a couple of list cols -DT[, l_1 := DT[, list(c=list(rep(i_1, sample(5, 1L)))), by = i_1]$c] -DT[, l_2 := DT[, list(c=list(rep(c_1, sample(5, 1L)))), by = i_1]$c] - -# id.vars, measure.vars as character/integer/numeric vectors -melt(DT, id.vars=1:2, measure.vars=""f_1"") -melt(DT, id.vars=c(""i_1"", ""n_1""), measure.vars=3) # same as above -melt(DT, id.vars=1:2, measure.vars=3L, value.factor=TRUE) # same, but 'value' is factor -melt(DT, id.vars=1:2, measure.vars=3:4, value.factor=TRUE) # 'value' is *ordered* factor - -# preserves attribute when types are identical, ex: Date -melt(DT, id.vars=3:4, measure.vars=c(""d_1"", ""d_2"")) -melt(DT, id.vars=3:4, measure.vars=c(""n_1"", ""d_1"")) # attribute not preserved - -# on list -melt(DT, id.vars=1, measure.vars=c(""l_1"", ""l_2"")) # value is a list -suppressWarnings( - melt(DT, id.vars=1, measure.vars=c(""c_1"", ""l_1"")) # c1 coerced to list, with warning -) - -# on character -melt(DT, id.vars=1, measure.vars=c(""c_1"", ""f_1"")) # value is char -suppressWarnings( - melt(DT, id.vars=1, measure.vars=c(""c_1"", ""n_1"")) # n_1 coerced to char, with warning -) - -# on na.rm=TRUE. NAs are removed efficiently, from within C -melt(DT, id.vars=1, measure.vars=c(""c_1"", ""c_2""), na.rm=TRUE) # remove NA - -# measure.vars can be also a list -# melt ""f_1,f_2"" and ""d_1,d_2"" simultaneously, retain 'factor' attribute -# convenient way using internal function patterns() -melt(DT, id.vars=1:2, measure.vars=patterns(""^f_"", ""^d_""), value.factor=TRUE) -melt(DT, id.vars=patterns(""[in]""), measure.vars=patterns(""^f_"", ""^d_""), value.factor=TRUE) -# same as above, but provide list of columns directly by column names or indices -melt(DT, id.vars=1:2, measure.vars=list(3:4, c(""d_1"", ""d_2"")), value.factor=TRUE) -# same as above, but provide names directly: -melt(DT, id.vars=1:2, measure.vars=patterns(f=""^f_"", d=""^d_""), value.factor=TRUE) - -# na.rm=TRUE removes rows with NAs in any 'value' columns -melt(DT, id.vars=1:2, measure.vars=patterns(""f_"", ""d_""), value.factor=TRUE, na.rm=TRUE) - -# 'na.rm=TRUE' also works with list column, but note that is.na only -# returns TRUE if the list element is a length=1 vector with an NA. -is.na(list(one.NA=NA, two.NA=c(NA,NA))) -melt(DT, id.vars=1:2, measure.vars=patterns(""l_"", ""d_""), na.rm=FALSE) -melt(DT, id.vars=1:2, measure.vars=patterns(""l_"", ""d_""), na.rm=TRUE) - -# measure list with missing/short entries results in output with runs of NA -DT.missing.cols <- DT[, .(d_1, d_2, c_1, f_2)] -melt(DT.missing.cols, measure.vars=list(d=1:2, c=""c_1"", f=c(NA, ""f_2""))) - -# specifying columns to melt via separator. -melt(DT.missing.cols, measure.vars=measure(value.name, number=as.integer, sep=""_"")) - -# specifying columns to melt via regex. -melt(DT.missing.cols, measure.vars=measure(value.name, number=as.integer, pattern=""(.)_(.)"")) -melt(DT.missing.cols, measure.vars=measure(value.name, number=as.integer, pattern=""([dc])_(.)"")) - ---- - -Future talks - -Past talks - -2025.06.27: Toby Hocking, Time and memory efficient R programming, French slides for R Ladies Paris online meetup, video. - -2025.06.24: What makes R strong - Atelier Global Actuarial Conference, Zurich, Switzerland - by Jan Gorecki, slides. - -2025.05.19: Toby Hocking, French slides for data.table tutorial at Recontres R, Mons, Belgium, data.table pour la traitement efficace des grands jeux de données. - -2025.05.15: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Bernd Bischl's lab meeting at LMU in Munich, slides. - -2025.05.08: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Zurich Applied Statistics seminar, announcement, slides. - -2025.03: Toby Hocking, Short talk about data.table for Julie Josse lab in Montpellier, slides - -2025.02: Toby Hocking, Madrid R User Group, Video. - -2024.12: Toby Hocking, PyData Global, Dec 2024, Video. - -2024.11.07: R package dependencies in production - III Congress & XIV R User Conference, Sevilla, Spain - by Jan Gorecki, slides. - -2024.10.15: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, ""Women in Statistics and Data Science conference 2024"" Presentation Speed Talk and Poster Presentation - -2024.08.06: ""Creating a self-sustaining ecosystem for data.table"" by Ani, JSM 2024 (Portland, Oregon), Slides - -2024.08.06: Tyson S. Barrett, ""Efficient Tools for Your Tidy Workflow: A case for incorporating data.table"", JSM 2024 in Portland, OR slides - -2024.07.11: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, useR! 2024 online presentation video, useR! 2024 presentation in Salzburg, Austria slides - -2024.07.09: Tyson S. Barrett, ""The Past, Present, and Future of data.table"", useR! 2024 presentation in Salzburg, Austria slides - -2024.05.18: Tyson S. Barrett, ""data.table: New Developments"", R Finance 2024 presentation in Chicago slides - -2024.03.28: Toby Dylan Hocking, R Project in Google Summer of Code, virtual talk for Chicago R User Group, slides. - -2024.03.05: ""GitHub Actions: Automated performance regression testing on pull requests"" by Ani, NAU SICCS (Flagstaff, AZ), Slides - -2024.02.29: David Shilane, R Programming: Introduction to data.table, course at Conference on Statistical Practice (CSP2024), slides and practice exercises - -2024.02.08: intro to data.table at SevillaR: High productivity data frame operations with data.table, by Jan Gorecki, slides, video. - -2024.01.26: Rolling statistics - Edinburgh R user group meeting, Edinburgh, United Kingdom, by Jan Gorecki, slides - -2023.10.18: Using and contributing to the data.table package for efficient big data analysis - LatinR meeting, Montevideo, Uruguay. * Original presentation by Toby Dylan Hocking, google slides, source files. * Spanish translation by Mara Destefanis. - -2020.04: Manejo eficiente de grandes volúmenes de datos usando el paquete data.table en R - Nestor Montano, Diapositivas Youtube Playlist Facebook Playlist - -2020.04: Data wrangling and cleaning with data.table - Grant McDermott, Big Data in Economics (UOregon) - -2020.02.01: Machine Learning and Data Munging in H2O Driverless AI with (python) datatable - Parul Pandey, Hyderabad AI & DL meetup - -2020.01.30: List-columns in data.table - Tyson Barrett, rstudio::conf(2020L) - -2019.12.26: Efficiency in data processing. data.table basics - Jan Gorecki, R@IISA 2019 - -2019.10 : data.table for R and Python, Matt Dowle, H2OWorld New York - -2019.10 : Why I love data.table, Chris Mainey, Warwick R User Group - -2019.09 : Introduction to data.table, Jan Gorecki, whyR? Warsaw - -2019.07 : Not So Standard Deviations; 84 - All The Easy Issues, Hilary Parker and Roger Peng - -2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk - -2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse - ---- - -## Why do `T` and `F` behave differently from `TRUE` and `FALSE` in some `data.table` queries? - -Using `T` and `F` as abbreviations for `TRUE` and `FALSE` in `data.table` can lead to unexpected behavior. This is because `T` and `F` are global variables that can be redefined, which causes them to be treated as variable names rather than logical constants. This issue does not occur with `TRUE` and `FALSE`. Avoiding `T` and `F` is advice for using R generally, but it shows up in `data.table` in some perhaps surprising ways, for example: - -```r -DT <- data.table(x=rep(c(""a"", ""b"", ""c""), each = 3), y=c(1, 3, 6), v=1:9) - -# Using TRUE/FALSE works as expected in cases like the ones below: - -DT[, .SD, .SDcols=c(TRUE, TRUE, FALSE)] -# A) This selects the first two columns (x and y) and excludes the third one (v). Output: -#> x y -#> 1: a 1 -#> 2: a 3 -#> 3: a 6 -#> 4: b 1 -#> 5: b 3 -#> 6: b 6 -#> 7: c 1 -#> 8: c 3 -#> 9: c 6 - -DT[, .SD, .SDcols=c(T, T, F), with=FALSE] -# B) This forces data.table to treat T/F as logical constants. -# Same output as DT[, .SD, .SDcols=c(TRUE, TRUE, FALSE)] - -# But, using T/F may lead to unexpected behavior in cases like: - -DT[, .SD, .SDcols=c(T, T, F)] -# data.table treats T and F as variable names here, not logical constants. Output: -#> Detected that j uses these columns: -#> [1] TRUE TRUE FALSE -``` - -As a general word of advice, `lintr::T_and_F_symbol_linter()` detects the usage of `T` and `F` and suggests replacing them with `TRUE` and `FALSE` to avoid such issues. - -# Questions relating to compute time - -## I have 20 columns and a large number of rows. Why is an expression of one column so quick? - -Several reasons: - - - Only that column is grouped, the other 19 are ignored because data.table inspects the `j` expression and realises it doesn't use the other columns. - - One memory allocation is made for the largest group only, then that memory is re-used for the other groups. There is very little garbage to collect. - - R is an in-memory column store; i.e., the columns are contiguous in RAM. Page fetches from RAM into L2 cache are minimised. - -## I don't have a `key` on a large table, but grouping is still really quick. Why is that? - -data.table uses radix sorting. This is significantly faster than other sort algorithms. See [our presentations](https://github.com/Rdatatable/data.table/wiki/Presentations) for more information, in particular from useR!2015 Denmark. - -This is also one reason why `setkey()` is quick. - -When no `key` is set, or we group in a different order from that of the key, we call it an _ad hoc_ `by`. - -## Why is grouping by columns in the key faster than an _ad hoc_ `by`? - -Because each group is contiguous in RAM, thereby minimising page fetches and memory can be -copied in bulk (`memcpy` in C) rather than looping in C. - -## What are primary and secondary indexes in data.table? - -Manual: [`?setkey`](https://www.rdocumentation.org/packages/data.table/functions/setkey) -S.O.: [What is the purpose of setting a key in data.table?](https://stackoverflow.com/questions/20039335/what-is-the-purpose-of-setting-a-key-in-data-table/20057411#20057411) - -`setkey(DT, col1, col2)` orders the rows by column `col1` then within each group of `col1` it orders by `col2`. This is a _primary index_. The row order is changed _by reference_ in RAM. Subsequent joins and groups on those key columns then take advantage of the sort order for efficiency. (Imagine how difficult looking for a phone number in a printed telephone directory would be if it wasn't sorted by surname then forename. That's literally all `setkey` does. It sorts the rows by the columns you specify.) The index doesn't use any RAM. It simply changes the row order in RAM and marks the key columns. Analogous to a _clustered index_ in SQL. - ---- - -#include ""data.table.h"" - ---- - -#include ""data.table.h"" - ---- - -3. When `j` contains no unquoted variable names (whether column names or not), `with=` is now automatically set to `FALSE`. Thus, `DT[,1]`, `DT[,""someCol""]`, `DT[,c(""colA"",""colB"")]` and `DT[,100:109]` now work as we all expect them to; i.e., returning columns, [#1188](https://github.com/Rdatatable/data.table/issues/1188), [#1149](https://github.com/Rdatatable/data.table/issues/1149). Since there are no variable names there is no ambiguity as to what was intended. `DT[,colName1:colName2]` no longer needs `with=FALSE` either since that is also unambiguous. That is a single call to the `:` function so `with=TRUE` could make no sense, despite the presence of unquoted variable names. These changes can be made since nobody can be using the existing behaviour of returning back the literal `j` value since that can never be useful. This provides a new ability and should not break any existing code. Selecting a single column still returns a 1-column data.table (not a vector, unlike `data.frame` by default) for type consistency for code (e.g. within `DT[...][...]` chains) that can sometimes select several columns and sometime one, as has always been the case in data.table. In future, `DT[,myCols]` (i.e. a single variable name) will look for `myCols` in calling scope without needing to set `with=FALSE` too, just as a single symbol appearing in `i` does already. The new behaviour can be turned on now by setting the tersely named option: `options(datatable.WhenJisSymbolThenCallingScope=TRUE)`. The default is currently `FALSE` to give you time to change your code. In this future state, one way (i.e. `DT[,theColName]`) to select the column as a vector rather than a 1-column data.table will no longer work leaving the two other ways that have always worked remaining (since data.table is still just a `list` after all): `DT[[""someCol""]]` and `DT$someCol`. Those base R methods are faster too (when iterated many times) by avoiding the small argument checking overhead inside the more flexible `DT[...]` syntax as has been highlighted in `example(data.table)` for many years. In the next release, `DT[,someCol]` will continue with old current behaviour but start to warn if the new option is not set. Then the default will change to TRUE to nudge you to move forward whilst still retaining a way for you to restore old behaviour for this feature only, whilst still allowing you to benefit from other new features of the latest release without changing your code. Then finally after an estimated 2 years from now, the option will be removed. - -### NEW FEATURES - - 1. `fwrite()` - parallel .csv writer: - * Thanks to Otto Seiskari for the initial pull request [#580](https://github.com/Rdatatable/data.table/issues/580) that provided C code, R wrapper, manual page and extensive tests. - * From there Matt parallelized and specialized C functions for writing integer/numeric exactly matching `write.csv` between 2.225074e-308 and 1.797693e+308 to 15 significant figures, dates (between 0000-03-01 and 9999-12-31), times down to microseconds in POSIXct, automatic quoting, `bit64::integer64`, `row.names` and `sep2` for `list` columns where each cell can itself be a vector. See [this blog post](https://blog.h2o.ai/2016/04/fast-csv-writing-for-r/) for implementation details and benchmarks. - * Accepts any `list` of same length vectors; e.g. `data.frame` and `data.table`. - * Caught in development before release to CRAN: thanks to Francesco Grossetti for [#1725](https://github.com/Rdatatable/data.table/issues/1725) (NA handling), Torsten Betz for [#1847](https://github.com/Rdatatable/data.table/issues/1847) (rounding of 9.999999999999998) and @ambils for [#1903](https://github.com/Rdatatable/data.table/issues/1903) (> 1 million columns). - * `fwrite` status was tracked here: [#1664](https://github.com/Rdatatable/data.table/issues/1664) - ---- - -9. `print.data.table()` (all via master issue [#1523](https://github.com/Rdatatable/data.table/issues/1523)): - - * gains `print.keys` argument, `FALSE` by default, which displays the keys and/or indices (secondary keys) of a `data.table`. Thanks @MichaelChirico for the PR, Yike Lu for the suggestion and Arun for honing that idea to its present form. - - * gains `col.names` argument, `""auto""` by default, which toggles which registers of column names to include in printed output. `""top""` forces `data.frame`-like behavior where column names are only ever included at the top of the output, as opposed to the default behavior which appends the column names below the output as well for longer (>20 rows) tables. `""none""` shuts down column name printing altogether. Thanks @MichaelChirico for the PR, Oleg Bondar for the suggestion, and Arun for guiding commentary. - - * list columns would print the first 6 items in each cell followed by a comma if there are more than 6 in that cell. Now it ends "",..."" to make it clearer, part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). Thanks to @franknarf1 for drawing attention to an issue raised on Stack Overflow by @TMOTTM [here](https://stackoverflow.com/q/47679701). - -10. `setkeyv` accelerated if key already exists [#2331](https://github.com/Rdatatable/data.table/issues/2331). Thanks to @MarkusBonsch for the PR. - -11. Keys and indexes are now partially retained up to the key column assigned to with ':=' [#2372](https://github.com/Rdatatable/data.table/issues/2372). They used to be dropped completely if any one of the columns was affected by `:=`. Tanks to @MarkusBonsch for the PR. - -12. Faster `as.IDate` and `as.ITime` methods for `POSIXct` and `numeric`, [#1392](https://github.com/Rdatatable/data.table/issues/1392). Thanks to Jan Gorecki for the PR. - -13. `unique(DT)` now returns `DT` early when there are no duplicates to save RAM, [#2013](https://github.com/Rdatatable/data.table/issues/2013). Thanks to Michael Chirico for the PR, and thanks to @mgahan for pointing out a reversion in `na.omit.data.table` before release, [#2660](https://github.com/Rdatatable/data.table/issues/2660#issuecomment-371027948). - -14. `uniqueN()` is now faster on logical vectors. Thanks to Hugh Parsonage for [PR#2648](https://github.com/Rdatatable/data.table/pull/2648). - - ```R - N = 1e9 - # was now - x = c(TRUE,FALSE,NA,rep(TRUE,N)) # - uniqueN(x) == 3 # 5.4s 0.00s - x = c(TRUE,rep(FALSE,N), NA) # - uniqueN(x,na.rm=TRUE) == 2 # 5.4s 0.00s - x = c(rep(TRUE,N),FALSE,NA) # - uniqueN(x) == 3 # 6.7s 0.38s - ``` - -15. Subsetting optimization with keys and indices is now possible for compound queries like `DT[a==1 & b==2]`, [#2472](https://github.com/Rdatatable/data.table/issues/2472). -Thanks to @MichaelChirico for reporting and to @MarkusBonsch for the implementation. - -16. `melt.data.table` now offers friendlier functionality for providing `value.name` for `list` input to `measure.vars`, [#1547](https://github.com/Rdatatable/data.table/issues/1547). Thanks @MichaelChirico and @franknarf1 for the suggestion and use cases, @jangorecki and @mrdwab for implementation feedback, and @MichaelChirico for ultimate implementation. - -17. `update.dev.pkg` is new function to update package from development repository, it will download package sources only when newer commit is available in repository. `data.table::update.dev.pkg()` defaults updates `data.table`, but any package can be used. - -18. Item 1 in NEWS for [v1.10.2](https://github.com/Rdatatable/data.table/blob/master/NEWS.md#changes-in-v1102--on-cran-31-jan-2017) on CRAN in Jan 2017 included : - ---- - -An _empty_ data.table (`DT[0]`) has one or more columns, all of which are empty. Those empty columns still have names and types. - -```{r} -DT = data.table(a = 1:3, b = c(4, 5, 6), d = c(7L,8L,9L)) -DT[0] -sapply(DT[0], class) -``` - -## Why has the `DT()` alias been removed? {#DTremove1} -`DT` was introduced originally as a wrapper for a list of `j `expressions. Since `DT` was an alias for data.table, this was a convenient way to take care of silent recycling in cases where each item of the `j` list evaluated to different lengths. The alias was one reason grouping was slow, though. - -As of v1.3, `list()` or `.()` should be passed instead to the `j` argument. These are much faster, especially when there are many groups. Internally, this was a non-trivial change. Vector recycling is now done internally, along with several other speed enhancements for grouping. - -## But my code uses `j = DT(...)` and it works. The previous FAQ says that `DT()` has been removed. {#DTremove2} - -Then you are using a version prior to 1.5.3. Prior to 1.5.3 `[.data.table` detected use of `DT()` in the `j` and automatically replaced it with a call to `list()`. This was to help the transition for existing users. - -## What are the scoping rules for `j` expressions? - -Think of the subset as an environment where all the column names are variables. When a variable `foo` is used in the `j` of a query such as `X[Y, sum(foo)]`, `foo` is looked for in the following order: - - 1. The scope of `X`'s subset; _i.e._, `X`'s column names. - 2. The scope of each row of `Y`; _i.e._, `Y`'s column names (_join inherited scope_) - 3. The scope of the calling frame; _e.g._, the line that appears before the data.table query. - 4. Exercise for reader: does it then ripple up the calling frames, or go straight to `globalenv()`? - 5. The global environment - -This is _lexical scoping_ as explained in [R FAQ 3.3.1](https://cran.r-project.org/doc/FAQ/R-FAQ.html#Lexical-scoping). The environment in which the function was created is not relevant, though, because there is _no function_. No anonymous _function_ is passed to `j`. Instead, an anonymous _body_ is passed to `j`; for example, - -```{r} -DT = data.table(x = rep(c(""a"", ""b""), c(2, 3)), y = 1:5) -DT -DT[ , {z = sum(y); z + 3}, by = x] -``` - -Some programming languages call this a _lambda_. - -## Can I trace the `j` expression as it runs through the groups? {#j-trace} - -Try something like this: - -```{r} -DT[ , { - cat(""Objects:"", paste(objects(), collapse = "",""), ""\n"") - cat(""Trace: x="", as.character(x), "" y="", y, ""\n"") - sum(y)}, - by = x] -``` - -## Inside each group, why are the group variables length-1? - -[Above](#j-trace), `x` is a grouping variable and (as from v1.6.1) has `length` 1 (if inspected or used in `j`). It's for efficiency and convenience. Therefore, there is no difference between the following two statements: - -```{r} -DT[ , .(g = 1, h = 2, i = 3, j = 4, repeatgroupname = x, sum(y)), by = x] -DT[ , .(g = 1, h = 2, i = 3, j = 4, repeatgroupname = x[1], sum(y)), by = x] -``` - -If you need the size of the current group, use `.N` rather than calling `length()` on any column. - -## Only the first 10 rows are printed, how do I print more? - -There are two things happening here. First, if the number of rows in a data.table are large (`> 100` by default), then a summary of the data.table is printed to the console by default. Second, the summary of a large data.table is printed by taking the top and bottom `n` (`= 5` by default) rows of the data.table and only printing those. Both of these parameters (when to trigger a summary and how much of a table to use as a summary) are configurable by R's `options` mechanism, or by calling the `print` function directly. - ---- - -# data.table news and updates (historical) - -**This is OLD NEWS. Latest news is on GitHub [here](https://github.com/Rdatatable/data.table/blob/master/NEWS.md).** - -## data.table [v1.14.10](https://github.com/Rdatatable/data.table/milestone/20?closed=1) (8 Dec 2023) - -### NOTES - -1. Maintainer of the package for CRAN releases is from now on Tyson Barrett (@tysonstanley), [#5710](https://github.com/Rdatatable/data.table/issues/5710). - -2. Updated internal code for breaking change of `is.atomic(NULL)` in R-devel, [#5691](https://github.com/Rdatatable/data.table/pull/5691). Thanks to Martin Maechler for the patch. - -3. Fix multiple test concerning coercion to missing complex numbers, [#5695](https://github.com/Rdatatable/data.table/issues/5695) and [#5748](https://github.com/Rdatatable/data.table/issues/5748). Thanks to @MichaelChirico and @ben-schwen for the patches. - -4. Fix multiple format warnings (e.g., -Wformat) [#5712](https://github.com/Rdatatable/data.table/pull/5712), [#5781](https://github.com/Rdatatable/data.table/pull/5781), [#5800](https://github.com/Rdatatable/data.table/pull/5800), [#5786](https://github.com/Rdatatable/data.table/pull/5786). Thanks to @MichaelChirico and @jangorecki for the patches. - - -## data.table [v1.14.8](https://github.com/Rdatatable/data.table/milestone/28?closed=1) (17 Feb 2023) - -### NOTES - -1. Test 1613.605 now passes changes to `as.data.frame()` in R-devel, [#5597](https://github.com/Rdatatable/data.table/pull/5597). Thanks to Avraham Adler for reporting. - -2. An out of bounds read when combining non-equi join with `by=.EACHI` has been found and fixed thanks to clang ASAN, [#5598](https://github.com/Rdatatable/data.table/issues/5598). There was no bug or consequence because the read was followed (now preceded) by a bounds test. - -3. `.rbind.data.table` (note the leading `.`) is no longer exported when `data.table` is installed in R>=4.0.0 (Apr 2020), [#5600](https://github.com/Rdatatable/data.table/pull/5600). It was never documented which R-devel now detects and warns about. It is only needed by `data.table` internals to support R<4.0.0; see note 1 in v1.12.6 (Oct 2019) below in this file for more details. - - -## data.table [v1.14.6](https://github.com/Rdatatable/data.table/milestone/27?closed=1) (16 Nov 2022) - -### BUG FIXES - -1. `fread()` could leak memory, [#3292](https://github.com/Rdatatable/data.table/issues/3292). Thanks to @patrickhowerter for reporting, and Jim Hester for the fix. The fix requires R 3.4.0 or later. Loading `data.table` in earlier versions now highlights this issue on startup, asks users to upgrade R, and warns that we intend to upgrade `data.table`'s dependency from 8 year old R 3.1.0 (April 2014) to 5 year old R 3.4.0 (April 2017). - -### NOTES - -1. Test 1962.098 has been modified to pass latest changes to `POSIXt` in R-devel. - -2. `test.data.table()` no longer creates `DT` in `.GlobalEnv`, a CRAN policy violation, [#5514](https://github.com/Rdatatable/data.table/issues/5514). No other writes occurred to `.GlobalEnv` and release procedures have been improved to prevent this happening again. - -3. The memory usage of the test suite has been halved, [#5507](https://github.com/Rdatatable/data.table/issues/5507). - - -## data.table [v1.14.4](https://github.com/Rdatatable/data.table/milestone/26?closed=1) (17 Oct 2022) - -### NOTES - -1. gcc 12.1 (May 2022) now detects and warns about an always-false condition (`-Waddress`) in `fread` which caused a small efficiency saving never to be invoked, [#5476](https://github.com/Rdatatable/data.table/pull/5476). Thanks to CRAN for testing latest versions of compilers. - ---- - -### NOTES - -1. `rbindlist`'s `use.names=""check""` now emits its message for automatic column names (`""V[0-9]+""`) too, [#3484](https://github.com/Rdatatable/data.table/pull/3484). See news item 5 of v1.12.2 below. - -2. Adding a new column by reference using `set()` on a `data.table` loaded from binary file now give a more helpful error message, [#2996](https://github.com/Rdatatable/data.table/issues/2996). Thanks to Joseph Burling for reporting. - - ``` - This data.table has either been loaded from disk (e.g. using readRDS()/load()) or constructed - manually (e.g. using structure()). Please run setDT() or alloc.col() on it first (to pre-allocate - space for new columns) before adding new columns by reference to it. - ``` - -3. `setorder` on a superset of a keyed `data.table`'s key now retains its key, [#3456](https://github.com/Rdatatable/data.table/issues/3456). For example, if `a` is the key of `DT`, `setorder(DT, a, -v)` will leave `DT` keyed by `a`. - -4. New option `options(datatable.quiet = TRUE)` turns off the package startup message, [#3489](https://github.com/Rdatatable/data.table/issues/3489). `suppressPackageStartupMessages()` continues to work too. Thanks to @leobarlach for the suggestion inspired by `options(tidyverse.quiet = TRUE)`. We don't know of a way to make a package respect the `quietly=` option of `library()` and `require()` because the `quietly=` isn't passed through for use by the package's own `.onAttach`. If you can see how to do that, please submit a patch to R. - -5. When loading a `data.table` from disk (e.g. with `readRDS`), best practice is to run `setDT()` on the new object to assure it is correctly allocated memory for new column pointers. Barring this, unexpected behavior can follow; for example, if you assign a new column to `DT` from a function `f`, the new columns will only be assigned within `f` and `DT` will be unchanged. The `verbose` messaging in this situation is now more helpful, [#1729](https://github.com/Rdatatable/data.table/issues/1729). Thanks @vspinu for sharing his experience to spur this. - -6. New vignette _Using `.SD` for Data Analysis_, a deep dive into use cases for the `.SD` variable to help illuminate this topic which we've found to be a sticking point for beginning and intermediate `data.table` users, [#3412](https://github.com/Rdatatable/data.table/issues/3412). - -7. Added a note to `?frank` clarifying that ranking is being done according to C sorting (i.e., like `forder`), [#2328](https://github.com/Rdatatable/data.table/issues/2328). Thanks to @cguill95 for the request. - -8. Historically, `dcast` and `melt` were built as enhancements to `reshape2`'s own `dcast`/`melt`. We removed dependency on `reshape2` in v1.9.6 but maintained some backward compatibility. As that package has been superseded since December 2017, we will begin to formally complete the split from `reshape2` by removing some last vestiges. In particular we now warn when redirecting to `reshape2` methods and will later error before ultimately completing the split; see [#3549](https://github.com/Rdatatable/data.table/issues/3549) and [#3633](https://github.com/Rdatatable/data.table/issues/3633). We thank the `reshape2` authors for their original inspiration for these functions, and @ProfFancyPants for testing and reporting regressions in dev which have been fixed before release. - -9. `DT[col]` where `col` is a column containing row numbers of itself to select, now suggests the correct syntax (`DT[(col)]` or `DT[DT$col]`), [#697](https://github.com/Rdatatable/data.table/issues/697). This expands the message introduced in [#1884](https://github.com/Rdatatable/data.table/issues/1884) for the case where `col` is type `logical` and `DT[col==TRUE]` is suggested. - ---- - -# Ensure that data.table options in code match documentation -options_documentation_linter = function(rd_file) { - if (!grepl(""\\name{data.table-options}"", readChar(rd_file, 100L), fixed = TRUE)) return(invisible()) - - # Find options in R code - walk_r_ast_for_options = function(expr) { - if (is.call(expr) && length(expr) >= 2L && identical(expr[[1L]], quote(getOption)) && is.character(e2 <- expr[[2L]]) && startsWith(e2, ""datatable."")) { - e2 - } else if (is.recursive(expr)) { - unlist(lapply(expr, walk_r_ast_for_options)) - } - } - - # Find options in documentation - walk_rd_ast_for_options = function(rd_element) { - if (!is.list(rd_element)) return(character()) - - result = character() - if (isTRUE(attr(rd_element, ""Rd_tag"") == ""\\code"") && length(rd_element) >= 1L) { - content = rd_element[[1L]] - if (is.character(content) && startsWith(content, ""datatable."")) { - result = content - } - } - c(result, unlist(lapply(rd_element, walk_rd_ast_for_options))) - } - - code_opts = list.files(""R"", pattern = ""\\.R$"", full.names = TRUE) |> - lapply(\(f) lapply(parse(f), walk_r_ast_for_options)) |> - unlist() |> - unique() |> - setdiff(""datatable.nomatch"") # ignore deprecated option(s) - - doc_opts = rd_file |> - tools::parse_Rd() |> - walk_rd_ast_for_options() |> - unique() - - miss_in_doc = setdiff(code_opts, doc_opts) - miss_in_code = setdiff(doc_opts, code_opts) - - if (length(miss_in_doc) > 0L || length(miss_in_code) > 0L) { - if (length(miss_in_doc) > 0L) { - cat(sprintf(""Options in code but missing from docs: %s\n"", toString(miss_in_doc))) - } - if (length(miss_in_code) > 0L) { - cat(sprintf(""Options in docs but not in code: %s\n"", toString(miss_in_code))) - } - stop(""Please sync man/data.table-options.Rd with code options"") - } -} - ---- - -\name{cdt} -\alias{cdatatable} -\title{ data.table exported C routines } -\description{ - Some of the internally used C routines are now exported. This interface should be considered experimental. List of exported C routines and their signatures are provided below in the usage section. -} -\usage{ -# SEXP DT_subsetDT(SEXP x, SEXP rows, SEXP cols); -# p_DT_subsetDT = R_GetCCallable(""data.table"", ""DT_subsetDT""); -} -\details{ - Details on how to use these can be found in the \emph{Writing R Extensions} manual \emph{Linking to native routines in other packages} section. - An example use with \code{Rcpp}: -\preformatted{ - dt = data.table::as.data.table(iris) - Rcpp::cppFunction(""SEXP mysub2(SEXP x, SEXP rows, SEXP cols) { return DT_subsetDT(x,rows,cols); }"", - include=""#include "", - depends=""data.table"") - mysub2(dt, 1:4, 1:4) -} -} -\note{ - Be aware C routines are likely to have less input validation than their corresponding R interface. For example one should not expect \code{DT[-5L]} will be equal to \code{.Call(DT_subsetDT, DT, -5L, seq_along(DT))} because translation of \code{i=-5L} to \code{seq_len(nrow(DT))[-5L]} might be happening on R level. Moreover checks that \code{i} argument is in range of \code{1:nrow(DT)}, missingness, etc. might be happening on R level too. -} -\references{ - \url{https://cran.r-project.org/doc/manuals/r-release/R-exts.html} -} -\keyword{ data } - ---- - -## OK, je commence à comprendre ce qu'est data.table, mais pourquoi n'avez-vous pas simplement amélioré `data.frame` dans R ? Pourquoi faut-il que ce soit un nouveau package ? - -Comme [souligné ci-dessus] (#j-num), `j` dans `[.data.table` est fondamentalement différent de `j` dans `[.data.frame`. Même si quelque chose d'aussi simple que `DF[ , 1]` était modifié dans la base R pour retourner un data.frame plutôt qu'un vecteur, cela casserait le code existant dans des milliers de package CRAN et dans le code utilisateur. Dès que nous avons pris la décision de créer une nouvelle classe héritant de data.frame, nous avons eu l'opportunité de changer certaines choses et nous l'avons fait. Nous voulons que data.table soit légèrement différent et qu'il fonctionne de cette façon pour que la syntaxe plus compliquée fonctionne. Il existe également d'autres différences (voir [ci-dessous](#PetitesDifférences) ). - -De plus, data.table *hérite* de `data.frame`. C'est aussi un `data.frame`. Un data.table peut être passé à n'importe quel package qui n'accepte que `data.frame` et ce package peut utiliser la syntaxe `[.data.frame` sur le data.table. Voir [cette réponse] (https://stackoverflow.com/a/10529888/403310) pour savoir comment procéder. - -Nous avons également proposé des améliorations à R chaque fois que cela était possible. L'une d'entre elles a été acceptée comme nouvelle fonctionnalité dans R 2.12.0 : - -> `unique()` et `match()` sont maintenant plus rapides sur les vecteurs de caractères où tous les éléments sont dans le cache global CHARSXP et ont un encodage non marqué (ASCII). Merci à Matt Dowle pour avoir suggéré des améliorations dans la façon dont le code de hachage est généré dans unique.c. - -Une deuxième proposition était d'utiliser `memcpy` dans duplicate.c, qui est beaucoup plus rapide qu'une boucle for en C. Cela améliorerait la *manière* dont R copie les données en interne (sur certaines mesures, de 13 fois). Le fil de discussion sur r-devel est [ici] (https://stat.ethz.ch/pipermail/r-devel/2010-April/057249.html). - -Une troisième proposition plus significative qui a été acceptée est que R utilise maintenant le code de tri par base (radix sort) de data.table à partir de R 3.3.0 : - -> L'algorithme de tri par base (radix sort) et l'implémentation de data.table (forder) remplace l'ancien tri par base (comptage) et ajoute une nouvelle méthode pour order(). Proposé par Matt Dowle et Arun Srinivasan, le nouvel algorithme supporte les vecteurs de logiques, d’entiers (même avec de grandes valeurs), de réels et de caractères. Il est plus performant que toutes les autres méthodes, mais il y a quelques mises en garde (voir ?sort). - -C'était un grand événement pour nous et nous l'avons fêté jusqu'à ce que les vaches rentrent à la maison. (Pas vraiment.) - -## Pourquoi les valeurs par défaut sont-elles telles qu'elles sont ? Pourquoi le système fonctionne-t-il comme il le fait ? - -La réponse est simple : l'auteur principal l'a conçu à l'origine pour son propre usage. C'est ce qu'il voulait. Il trouve que c'est une façon plus naturelle et plus rapide d'écrire du code, qui s'exécute également plus rapidement. - -## N'est-ce pas déjà fait par `with()` et `subset()` dans `base` ? - -Certaines des caractéristiques discutées jusqu'à présent sont, oui. Le package s'appuie sur la fonctionnalité de base. Il fait le même genre de choses, mais avec moins de code et s'exécute beaucoup plus rapidement s'il est utilisé correctement. - -## Pourquoi `X[Y]` retourne-t-il aussi toutes les colonnes de `Y` ? Ne devrait-elle pas retourner un sous-ensemble de `X` ? - ---- - -#### Blanket import - -Alternatively, you can import all functions from `data.table` at once, though this is generally not recommended: - -```r -import(data.table) -``` - -**Justification for Avoiding Blanket Imports:** -1. **Documentation**: The NAMESPACE file can serve as good documentation of how you depend on certain packages. -2. **Avoiding Conflicts**: Blanket imports leave you open to subtle breakage. For example, if you `import(pkgA)` and `import(pkgB)`, but later pkgB exports a function also exported by pkgA, this will break your package due to conflicts in your namespace, which is disallowed by `R CMD check` and CRAN. - -### Step 3: Update Your R code files outside the package's R/ directory - -When you move a package from `Depends` to `Imports`, it will no longer be automatically attached when your package is loaded. This can be important for examples, tests, vignettes, and demos, where `Imports` packages need to be attached explicitly. - -**Before (with `Depends`):** -```r -# data.table functions are directly available -library(MyPkgDependsDataTable) -dt <- data.table(x = 1:10, y = letters[1:10]) -setDT(dt) -result <- merge(dt, other_dt, by = ""x"") -``` - -**After (with `Imports`):** -```r -# Explicitly load data.table in user scripts or vignettes -library(data.table) -library(MyPkgDependsDataTable) -dt <- data.table(x = 1:10, y = letters[1:10]) -setDT(dt) -result <- merge(dt, other_dt, by = ""x"") -``` - -### Benefits of using `Imports` -- **User-Friendliness**: `Depends` alters your users' `search()` path, possibly without their wanting to do so. -- **Namespace Management**: Only the functions your package explicitly imports are available, reducing the risk of function name clashes. -- **Cleaner Package Loading**: Your package's dependencies are not attached to the search path, making the loading process cleaner and potentially faster. -- **Easier Maintenance**: It simplifies maintenance tasks as upstream dependencies' APIs evolve. Depending too much on `Depends` can lead to conflicts and compatibility issues over time. - -```{r, echo = FALSE, message = FALSE} -data.table::setDTthreads(.old.th) -``` - ---- - -#ifdef ENABLE_NLS -#include -#define _(String) dgettext(""data.table"", String) -// NB: flip argument order to match that of R's ngettext() -#define Pl_(n, String1, StringPlural) dngettext(""data.table"", String1, StringPlural, n) -#else -#define _(String) (String) -#define Pl_(n, String1, StringPlural) ((n) == 1 ? (String1) : (StringPlural)) -#endif - ---- - -Le mécanisme des options dans R est *global*. Cela signifie que si un utilisateur définit une option `data.table` pour son propre usage, ce réglage affecte également le code de tout package qui utilise `data.table`. Pour une option comme `datable.verbose`, c'est exactement le comportement désiré puisque le but est de tracer et d'enregistrer toutes les opérations de `data.table` d'où qu'elles viennent ; activer la verbosité n'affecte pas les résultats. Une autre option unique à R et excellente pour la production est `options(warn=2)` qui transforme tous les avertissements en erreurs. Encore une fois, le but est d'affecter n'importe quel avertissement dans n'importe quel package afin de ne manquer aucun avertissement en production. Il y a 6 options `datable.print.*` et 3 options d'optimisation qui n'affectent pas le résultat des opérations. Cependant, il y a une option `data.table` qui l'affecte et qui est maintenant un problème : `datatable.nomatch`. Cette option change la jointure par défaut d'externe à interne. [A côté de cela, la jointure par défaut est externe parce que outer est plus sûr ; il ne laisse pas tomber les données manquantes silencieusement ; de plus, il est cohérent avec la façon dont la base R fait correspondre les noms et les indices]. Certains utilisateurs préfèrent que la jointure interne soit la valeur par défaut et nous avons prévu cette option pour eux. Cependant, un utilisateur qui met en place cette option peut involontairement changer le comportement des jointures à l'intérieur des packages qui utilisent `data.table`. En conséquence, dans la version 1.12.4 (Oct 2019), un message était affiché lorsque l'option `datable.nomatch` était utilisée, et à partir de la version 1.14.2, elle est maintenant ignorée avec un avertissement. C'était la seule option `datable.table` qui posait ce problème. - -## Dépannage - -Si vous rencontrez des problèmes lors de la création d'un package qui utilise data.table, veuillez confirmer que le problème est reproductible dans une session R propre en utilisant la console R : `R CMD check nom.package`. - -Certains des problèmes les plus courants auxquels les développeurs sont confrontés sont généralement liés à des outils d'aide destinés à automatiser certaines tâches de développement de package, par exemple, l'utilisation de `roxygen` pour générer votre fichier `NAMESPACE` à partir des métadonnées des fichiers de code R. D'autres sont liés aux outils d'aide qui construisent et vérifient les package. D'autres sont liées aux aides qui construisent et vérifient le package. Malheureusement, ces aides ont parfois des effets secondaires inattendus/cachés qui peuvent masquer la source de vos problèmes. Ainsi, assurez-vous de faire une double vérification en utilisant la console R (lancez R sur la ligne de commande) et assurez-vous que l'importation est définie dans les fichiers `DESCRIPTION` et `NAMESPACE` en suivant les [instructions](#DESCRIPTION) [ci-dessus](#NAMESPACE). - -Si vous n'êtes pas en mesure de reproduire les problèmes que vous rencontrez en utilisant la simple console R pour construire (""build"") et vérifier (""check""), vous pouvez essayer d'obtenir de l'aide en vous basant sur les problèmes que nous avons rencontrés dans le passé avec `data.table` interagissant avec des outils d'aide : [devtools#192](https://github.com/r-lib/devtools/issues/192) ou [devtools#1472](https://github.com/r-lib/devtools/issues/1472). - -## Licence - -Depuis la version 1.10.5, `data.table` est sous licence Mozilla Public License (MPL). Les raisons du changement de la GPL peuvent être lues en entier [ici](https://github.com/Rdatatable/data.table/pull/2456) et vous pouvez en savoir plus sur la MPL sur Wikipedia [ici](https://en.wikipedia.org/wiki/Mozilla_Public_License) et [ici](https://en.wikipedia.org/wiki/Comparison_of_free_and_open-source_software_licenses). - -## Importe optionnellement `data.table` : `Suggests` - ---- - -Using ggplot2 Inside data.table John Lashlee 2019.10 Fast and Readable 'If Else' in R Tysson Barrett 2019.10 Data Joins: Speed and Efficiency of dplyr and data.table Tysson Barrett 2019.10 Comparing Efficiency and Speed of data.table : Adding variables, filtering rows, and summarizing by group Tysson Barrett 2019.10 Columnar File Performance Check-in for Python and R: Parquet, Feather, and FST Wes McKinney 2019.09 Selecting the max value from each group, a case study: data.table Nathan Eastwood 2019.09 Sentiment analysis at the Fringe, part 1 Megan Stodel 2019.09 {disk.frame} is epic Bruno Rodrigues 2019.08 A shallow benchmark of R data frame export/import methods Julien Barnier 2019.08 The R Factor Owen Jones 2019.08 Hydra Chronicles, Part V: Loose Ends Brodie Gaslam 2019.08 Everyone’s Favorite Blogpost: CSV Benchmarks Jacob Quinn 2019.08 No visible binding for global variable Nathan Eastwood 2019.08 Why Machine Learning is more Practical than Econometrics in the Real World Adrian Antico 2019.08 What’s next for the popular programming language R? Dan Kopf 2019.08 Wrangling 4.6M Rows with dtplyr (the NEW data.table backend for dplyr) Matt Dancho 2019.08 mlr3-0.1.0 Patrick Schratz 2019.07 Hydra Chronicles, Part IV: Reformulation of Statistics Brodie Gaslam 2019.07 Multiple Columns to Multiple Colums at Once Recle Etino Vibal 2019.07 Long to Wide and Wide to Long Format Conversion Giovanni Pavolini 2019.07 fread-benchmarks-rsuite Alfonso R. Reyes 2019.07 Bayesian Power Analysis with data.table , tidyverse , and brms Tyson Barrett 2019.07 Making .SD your best friend José Morales 2019.07 data.table's cube function Giovanni Pavolini 2019.07 How to use .SD in the data.table package Sharon Machlis 2019.07 Why I Chose to Learn data.table (and such related things) Tyson Barrett 2019.07 What R’s most popular tools say about the state of data science Dan Kopf 2019.07 data.table and Text Analysis: Analyzing the Four Gospels Tyson Barrett 2019.07 Analyzing data with data.table Giovanni Pavolini 2019.07 Why I love data.table Elio Campitelli 2019.07 Why I like the Tidyverse Chris Muir 2019.07 An opinionated view of the Tidyverse ""dialect"" of the R language, and its promotion by RStudio Circa this revision on GitHub was in effect at the time and widely shared; e.g. HackerNews . Revision announced 2022.04 . Norm Matloff 2019.06 Learning Japanese with data.table and ggplot2 Atrebas 2019.06 data.table by a dummy John MacKintosh 2019.06 My Favorite data.table Feature John Mount 2019.06 Coke vs. Pepsi? data.table vs. tidy? Part 2) Beth Milhollin, Russell Zaretzki, and Audris Mockus 2019.06 The Psychology of Flame Wars Edwin Thoen 2019.06 data.table is Much Better Than You Have Been Told John Mount 2019.06 data.table is expressive and powerful Michael Frasco 2019.06 How data.table's fread can save you a lot of time and memory, and take input from shell commands Jozef Hajnala 2019.06 Hydra Chronicles, part III: Catastrophic Imprecision Brodie Gaslam 2019.06 Hydra Chronicles, part II: beating data.table at its own game Brodie Gaslam 2019.06 An Overview of Python's Datatable package Parul Pandey 2019.06 For and Against data.table Aaron Jacobs 2019.05 Three reasons why I use data.table Megan Stodel 2019.05 Timing Working With a Row or a Column from a data.frame John Mount 2019.05 Using Data Cubes with R Kristian Larsen 2019.05 cranlogs 2.1.1 is on CRAN! R-hub blog 2019.05 R package installation on windows considered harmful Toby Dylan Hocking 2019.05 Hydra Chronicles, part I: Pixie Dust Brodie Gaslam 2019.04 Using data.table with magrittr pipes: best of both worlds Martin Chan 2019.04 What are the Popular R Packages? John Mount 2019.04 Coke vs. Pepsi? data.table vs. tidy? Examining Consumption Preferences for Data Scientists Audris Mockus 2019.03 A data.table and dplyr tour Atrebas 2019.03 Dependencies. Now with badges! Dirk Eddelbuettel 2019.03 Unit Tests in R John Mount 2019.03 Creating blazing fast pivot tables from R with data.table - now with - ---- - -#: data.table.R:139 -#, c-format -msgid ""Item '%s' not found in names of input list"" -msgstr ""Élément '%s' non trouvé parmi les noms de la liste d'entrée"" - -#: data.table.R:159 -#, c-format -msgid """" -""[ was called on a data.table in an environment that is not data.table-aware "" -""(i.e. cedta()), but '%s' was used, implying the owner of this call really "" -""intended for data.table methods to be called. See vignette('datatable-"" -""importing') for details on properly importing data.table."" -msgstr """" -""[ a été appelé sur un data.table dans un environnement qui n'est pas "" -""compatible avec data.table (i.e. cedta()), mais '%s' a été utilisé, ce qui "" -""implique que le propriétaire de cet appel avait vraiment l'intention "" -""d'appeler des méthodes data.table. Voir la vignette('datatable-importing') "" -""pour plus de détails sur l’importation correcte de data.table."" - -#: data.table.R:170 -#, c-format -msgid ""verbose must be logical or integer"" -msgstr ""verbose doit être soit un booléen, soit un entier"" - -#: data.table.R:171 -#, c-format -msgid ""verbose must be length 1 non-NA"" -msgstr ""verbose doit être de longueur 1 et différent de NA"" - -#: data.table.R:179 -#, c-format -msgid ""Ignoring by/keyby because 'j' is not supplied"" -msgstr ""L'argument by ou keyby est ignoré car 'j' n'est pas fourni"" - -#: data.table.R:193 -#, c-format -msgid ""When by and keyby are both provided, keyby must be TRUE or FALSE"" -msgstr """" -""Si by et keyby sont fournis simultanément, keyby doit être TRUE ou FALSE"" - -#: data.table.R:196 data.table.R:261 data.table.R:351 -msgid ""Argument '%s' after substitute: %s"" -msgstr ""Argument '%s' après substitution : %s"" - -#: data.table.R:205 -#, c-format -msgid """" -""When on= is provided but not i=, on= must be a named list or data.table|"" -""frame, and a natural join (i.e. join on common names) is invoked. Ignoring "" -""on= which is '%s'."" -msgstr """" -""Lorsque on= est fourni mais pas i=, on= doit être une liste nommée ou un "" -""data.table|frame, et une jointure naturelle (c'est-à-dire une jointure sur "" -""les noms communs) est invoquée. La valeur de on= qui est '%s' est ignorée."" - -#: data.table.R:218 -#, c-format -msgid """" -""i and j are both missing so ignoring the other arguments. This warning will "" -""be upgraded to error in future."" -msgstr """" -""i et j sont tous les deux absents, donc les autres arguments sont ignorés. "" -""Cet avertissement deviendra une erreur à l'avenir."" - -#: data.table.R:222 -#, c-format -msgid ""mult argument can only be 'first', 'last', 'all' or 'error'"" -msgstr ""l'argument mult ne peut valoir que 'first', 'last', 'all' ou 'error'"" - -#: data.table.R:224 -#, c-format -msgid """" -""roll must be a single TRUE, FALSE, positive/negative integer/double "" -""including +Inf and -Inf or 'nearest'"" -msgstr """" -""roll doit être une seule valeur TRUE, FALSE, un entier ou un double, positif "" -""ou négatif, +Inf, -Inf ou 'nearest' compris"" - -#: data.table.R:226 -#, c-format -msgid ""roll is '%s' (type character). Only valid character value is 'nearest'."" -msgstr """" -""roll vaut '%s' (de type caractère). La seule chaîne valide est 'nearest'."" - -#: data.table.R:231 -#, c-format -msgid ""rollends must be a logical vector"" -msgstr ""rollends doit être un vecteur de booléens"" - -#: data.table.R:232 -#, c-format -msgid ""rollends must be length 1 or 2"" -msgstr ""rollends doit être de longueur 1 ou 2"" - -#: data.table.R:240 -#, c-format -msgid """" -""nomatch= must be either NA or NULL (or 0 for backwards compatibility which "" -""is the same as NULL but please use NULL)"" -msgstr """" -""nomatch= doit valoir soit NA, soit NULL (ou 0 pour la compatibilité arrière "" -""qui équivaut à NULL, mais utiliser NULL dorénavant)"" - -#: data.table.R:243 -#, c-format -msgid ""which= must be a logical vector length 1. Either FALSE, TRUE or NA."" -msgstr """" -""which= doit être un vecteur de booléens de longueur 1. Valeur FALSE, TRUE ou "" -""NA."" - ---- - -3. `print` method for `data.table` gains `trunc.cols` argument (and corresponding option `datatable.print.trunc.cols`, default `FALSE`), [#1497](https://github.com/Rdatatable/data.table/issues/1497), part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). This prints only as many columns as fit in the console without wrapping to new lines (e.g., the first 5 of 80 columns) and a message that states the count and names of the variables not shown. When `class=TRUE` the message also contains the classes of the variables. `data.table` has always automatically truncated _rows_ of a table for efficiency (e.g. printing 10 rows instead of 10 million); in the future, we may do the same for _columns_ (e.g., 10 columns instead of 20,000) by changing the default for this argument. Thanks to @nverno for the initial suggestion and to @TysonStanley for the PR. - -4. `setnames(DT, new=new_names)` (i.e. explicitly named `new=` argument) now works as expected rather than an error message requesting that `old=` be supplied too, [#4041](https://github.com/Rdatatable/data.table/issues/4041). Thanks @Kodiologist for the suggestion. - -5. `nafill` and `setnafill` gain `nan` argument to say whether `NaN` should be considered the same as `NA` for filling purposes, [#4020](https://github.com/Rdatatable/data.table/issues/4020). Prior versions had an implicit value of `nan=NaN`; the default is now `nan=NA`, i.e., `NaN` is treated as if it's missing. Thanks @AnonymousBoba for the suggestion. Also, while `nafill` still respects `getOption('datatable.verbose')`, the `verbose` argument has been removed. - -6. New function `fcase(...,default)` implemented in C by Morgan Jacob, [#3823](https://github.com/Rdatatable/data.table/issues/3823), is inspired by SQL `CASE WHEN` which is a common tool in SQL for e.g. building labels or cutting age groups based on conditions. `fcase` is comparable to R function `dplyr::case_when` however it evaluates its arguments in a lazy way (i.e. only when needed) as shown below. Please see `?fcase` for more details. - - ```R - # Lazy evaluation - x = 1:10 - data.table::fcase( - x < 5L, 1L, - x >= 5L, 3L, - x == 5L, stop(""provided value is an unexpected one!"") - ) - # [1] 1 1 1 1 3 3 3 3 3 3 - - dplyr::case_when( - x < 5L ~ 1L, - x >= 5L ~ 3L, - x == 5L ~ stop(""provided value is an unexpected one!"") - ) - # Error in eval_tidy(pair$rhs, env = default_env) : - # provided value is an unexpected one! - - # Benchmark - x = sample(1:100, 3e7, replace = TRUE) # 114 MB - microbenchmark::microbenchmark( - dplyr::case_when( - x < 10L ~ 0L, - x < 20L ~ 10L, - x < 30L ~ 20L, - x < 40L ~ 30L, - x < 50L ~ 40L, - x < 60L ~ 50L, - x > 60L ~ 60L - ), - data.table::fcase( - x < 10L, 0L, - x < 20L, 10L, - x < 30L, 20L, - x < 40L, 30L, - x < 50L, 40L, - x < 60L, 50L, - x > 60L, 60L - ), - times = 5L, - unit = ""s"") - # Unit: seconds - # expr min lq mean median uq max neval - # dplyr::case_when 11.57 11.71 12.22 11.82 12.00 14.02 5 - # data.table::fcase 1.49 1.55 1.67 1.71 1.73 1.86 5 - ``` - -7. `.SDcols=is.numeric` now works; i.e., `SDcols=` accepts a function which is used to select the columns of `.SD`, [#3950](https://github.com/Rdatatable/data.table/issues/3950). Any function (even _ad hoc_) that returns scalar `TRUE`/`FALSE` for each column will do; e.g., `.SDcols=!is.character` will return _non_-character columns (_a la_ `Negate()`). Note that `.SDcols=patterns(...)` can still be used for filtering based on the column names. - ---- - -9. `isoweek()` is much faster (e.g. 20x) by re-using an implementation from {base}, [#5111](https://github.com/Rdatatable/data.table/issues/5111). Thanks @MichaelChirico for the report and PR. - -10. `data.table()` and `as.data.table()` with `keep.rownames=TRUE` now extract row names from named vectors, matching `data.frame()` behavior. Names from the first named vector in the input are used to create the row names column (default name `""rn""` or custom name via `keep.rownames=""column_name""`), [#1916](https://github.com/Rdatatable/data.table/issues/1916). Thanks to @richierocks for the feature request and @Mukulyadav2004 for the implementation. - -11. New `frev(x)` as a faster analogue to `base::rev()` for atomic vectors/lists, [#5885](https://github.com/Rdatatable/data.table/issues/5885). Twice as fast as `base::rev()` on large inputs, and faster with more threads. Thanks to Benjamin Schwendinger for suggesting and implementing. - -12. New `cbindlist()` and `setcbindlist()` for concatenating a `list` of data.tables column-wise, evocative of the analogous `do.call(rbind, l)` <-> `rbindlist(l)`, [#2576](https://github.com/Rdatatable/data.table/issues/2576). `setcbindlist()` does so without making any copies. Thanks @MichaelChirico for the FR, @jangorecki for the PR, and @MichaelChirico for extensive reviews and fine-tuning. - - ```r - l = list( - data.table(id = 1:3, a = letters[1:3]), - data.table(b = 4:6, c = 7:9) - ) - cbindlist(l) - # id a b c - # 1: 1 a 4 7 - # 2: 2 b 5 8 - # 3: 3 c 6 9 - ``` - -13. New `mergelist()` and `setmergelist()` similarly work _a la_ `Reduce()` to recursively merge a `list` of data.tables, [#599](https://github.com/Rdatatable/data.table/issues/599). Different join modes (_left_, _inner_, _full_, _right_, _semi_, _anti_, and _cross_) are supported through the `how` argument; duplicate handling goes through the `mult` argument. `setmergelist()` carefully avoids copies where one is not needed, e.g. in a 1:1 left join. Thanks Patrick Nicholson for the FR (in 2013!), @jangorecki for the PR, and @MichaelChirico for extensive reviews and fine-tuning. - - ```r - l = list( - data.table(id = c(1L, 2L, 3L), x = c(""a"", ""b"", ""c"")), - data.table(id = c(1L, 2L, 4L), y = c(""d"", ""e"", ""f"")), - data.table(id = c(1L, 3L, 4L), z = c(""g"", ""h"", ""i"")) - ) - - # Recursive inner join - mergelist(l, on = ""id"", how = ""inner"") - # id x y z - # 1: 1 a d g - - # Recursive left join (the default 'how') - mergelist(l, on = ""id"", how = ""left"") - # id x y z - # 1: 1 a d g - # 2: 2 b e - # 3: 3 c h - ``` - -14. `fcoalesce()` and `setcoalesce()` gain `nan` argument to control whether `NaN` values should be treated as missing (`nan=NA`, the default) or non-missing (`nan=NaN`), [#4567](https://github.com/Rdatatable/data.table/issues/4567). This provides full compatibility with `nafill()` behavior. Thanks to @ethanbsmith for the feature request and @Mukulyadav2004 for the implementation. - -15. New function `isoyear()` has been implemented as a complement to `isoweek()`, returning the ISO 8601 year corresponding to a given date, [#7154](https://github.com/Rdatatable/data.table/issues/7154). Thanks to @ben-schwen and @MichaelChirico for the suggestion and @venom1204 for the implementation. - ---- - -```{r} -DT = data.table( - ID = c(""b"",""b"",""b"",""a"",""a"",""c""), - a = 1:6, - b = 7:12, - c = 13:18 -) -DT -class(DT$ID) -``` - -Vous pouvez aussi convertir des objets existants en une `data.table` en utilisant `setDT()` (pour les structures `data.frame` et `list`) ou `as.data.table()` (pour les autres structures). Pour les autres détails concernant les différences (ce qui est hors du champ de cette vignette), voir `?setDT` et `?as.data.table`. - -#### Notez que : - -* Les numéros de ligne sont imprimés avec un `:` afin de séparer visuellement le numéro de ligne de la première colonne. - -* Lorsque le nombre de lignes à imprimer dépasse l'option globale `datatable.print.nrows` (défaut = `r getOption(""datatable.print.nrows"")`), il n'imprime automatiquement que les 5 premières et les 5 dernières lignes (comme on peut le voir dans la section [Data](#data)). Pour un grand `data.frame`, vous avez pu vous retrouver à attendre que des tables plus grandes s'impriment et se mettent en page, parfois sans fin. Cette restriction permet d'y remédier, et vous pouvez demander le nombre par défaut de la façon suivante : - - ```{.r} - getOption(""datatable.print.nrows"") - ``` - -* `data.table` ne définit ni n'utilise jamais de *nom de ligne*. Nous verrons pourquoi dans la [`vignette(""datatable-keys-fast-subset"", package=""data.table"")`](datatable-keys-fast-subset.html). - -### b) Forme générale - dans quel sens la 'data.table' est-elle *étendue* ? {#enhanced-1b} - -Par rapport à un `data.frame`, vous pouvez faire *beaucoup plus de choses* qu'extraire des lignes et sélectionner des colonnes dans la structure d'une `data.table`, par exemple, avec `[ ... ]` (Notez bien : nous pourrions aussi faire référence à écrire quelque chose dans `DT[...]` comme ""interroger `DT`"", par analogie ou similairement à SQL). Pour le comprendre il faut d'abord que nous regardions la *forme générale* de la syntaxe `data.table`, comme indiqué ci-dessous : - -```r -DT[i, j, by] - -## R: i j by -## SQL: where | order by select | update group by -``` - -Les utilisateurs ayant des connaissances SQL feront peut être directement le lien avec cette syntaxe. - -#### La manière de le lire (à haute voix) est : - -Utiliser `DT`, extraire ou trier les lignes en utilisant `i`, puis calculer `j`, grouper avec `by`. - -Commençons par voir 'i' et 'j' d'abord - en indiçant les lignes et en travaillant sur les colonnes. - -### c) Regrouper les lignes en 'i' {#subset-i-1c} - -#### -- Obtenir tous les vols qui ont ""JFK"" comme aéroport de départ pendant le mois de juin. - -```{r} -ans <- flights[origin == ""JFK"" & month == 6L] -head(ans) -``` - -* Dans le cadre d'un `data.table`, on peut se référer aux colonnes *comme s'il s'agissait de variables*, un peu comme dans SQL ou Stata. Par conséquent, nous nous référons simplement à `origin` et `month` comme s'il s'agissait de variables. Nous n'avons pas besoin d'ajouter le préfixe `vol$` à chaque fois. Néanmoins, l'utilisation de `flights$origin` et `flights$month` fonctionnerait parfaitement. - -* Les *indices de ligne* qui satisfont la condition `origin == ""JFK"" & month == 6L` sont calculés, et puisqu'il n'y a rien d'autre à faire, toutes les colonnes de `flights` aux lignes correspondant à ces *indices de ligne* sont simplement renvoyées sous forme d’un `data.table`. - -* Une virgule après la condition dans `i` n'est pas nécessaire. Mais `flights[origin == ""JFK"" & month == 6L, ]` fonctionnerait parfaitement. Avec un `data.frame`, cependant, la virgule est indispensable. - -#### -- Récupérer les deux premières lignes de `flights`. {#subset-rows-integer} - -```{r} -ans <- flights[1:2] -ans -``` - -* Dans ce cas, il n'y a pas de condition. Les indices des lignes sont déjà fournis dans `i`. Nous retournons donc un `data.table` avec toutes les colonnes de `flights` aux lignes pour ces *index de ligne*. - -#### -- Trier `flights` d'abord sur la colonne `origin` dans l'ordre *ascending*, puis par `dest` dans l'ordre *descendant* : - ---- - -(b) The functional form - -```r -DT[, `:=`(colA = valA, # valA is assigned to colA - colB = valB, # valB is assigned to colB - ... -)] -``` - -Note that the code above explains how `:=` can be used. They are not working examples. We will start using them on `flights` *data.table* from the next section. - -# - -* In (a), `LHS` takes a character vector of column names and `RHS` a *list of values*. `RHS` just needs to be a `list`, irrespective of how its generated (e.g., using `lapply()`, `list()`, `mget()`, `mapply()` etc.). This form is usually easy to program with and is particularly useful when you don't know the columns to assign values to in advance. - -* On the other hand, (b) is handy if you would like to jot some comments down for later. - -* The result is returned *invisibly*. - -* Since `:=` is available in `j`, we can combine it with `i` and `by` operations just like the aggregation operations we saw in the previous vignette. - -# - -In the two forms of `:=` shown above, note that we don't assign the result back to a variable. Because we don't need to. The input *data.table* is modified by reference. Let's go through examples to understand what we mean by this. - -For the rest of the vignette, we will work with `flights` *data.table*. - -## 2. Add/update/delete columns *by reference* - -### a) Add columns by reference {#ref-j} - -#### -- How can we add columns *speed* and *total delay* of each flight to `flights` *data.table*? - -```{r} -flights[, `:=`(speed = distance / (air_time/60), # speed in mph (mi/h) - delay = arr_delay + dep_delay)] # delay in minutes -head(flights) - -## alternatively, using the 'LHS := RHS' form -# flights[, c(""speed"", ""delay"") := list(distance/(air_time/60), arr_delay + dep_delay)] -``` - -#### Note that - -* We did not have to assign the result back to `flights`. - -* The `flights` *data.table* now contains the two newly added columns. This is what we mean by *added by reference*. - -* We used the functional form so that we could add comments on the side to explain what the computation does. You can also see the `LHS := RHS` form (commented). - -### b) Update some rows of columns by reference - *sub-assign* by reference {#ref-i-j} - -Let's take a look at all the `hours` available in the `flights` *data.table*: - -```{r} -# get all 'hours' in flights -flights[, sort(unique(hour))] -``` - -We see that there are totally `25` unique values in the data. Both *0* and *24* hours seem to be present. Let's go ahead and replace *24* with *0*. - -#### -- Replace those rows where `hour == 24` with the value `0` - -```{r} -# subassign by reference -flights[hour == 24L, hour := 0L] -``` - -* We can use `i` along with `:=` in `j` the very same way as we have already seen in the [`vignette(""datatable-intro"", package=""data.table"")`](datatable-intro.html) vignette. - -* Column `hour` is replaced with `0` only on those *row indices* where the condition `hour == 24L` specified in `i` evaluates to `TRUE`. - -* `:=` returns the result invisibly. Sometimes it might be necessary to see the result after the assignment. We can accomplish that by adding an empty `[]` at the end of the query as shown below: - - ```{r} - flights[hour == 24L, hour := 0L][] - ``` - -# -Let's look at all the `hours` to verify. - -```{r} -# check again for '24' -flights[, sort(unique(hour))] -``` - -#### Exercise: {#update-by-reference-question} - -What is the difference between `flights[hour == 24L, hour := 0L]` and `flights[hour == 24L][, hour := 0L]`? Hint: The latter needs an assignment (`<-`) if you would want to use the result later. - -If you can't figure it out, have a look at the `Note` section of `?"":=""`. - -### c) Delete column by reference - -#### -- Remove `delay` column - -```{r} -flights[, c(""delay"") := NULL] -head(flights) - -## or using the functional form -# flights[, `:=`(delay = NULL)] -``` - -#### {#delete-convenience} - -* Assigning `NULL` to a column *deletes* that column. And it happens *instantly*. - ---- - -\code{IDateTime} takes a date-time input and returns a data table with -columns \code{date} and \code{time}. - -Using integer storage allows dates and/or times to be used as data table -keys. With positive integers with a range less than 100,000, grouping -and sorting is fast because radix sorting can be used (see -\code{sort.list}). - -Several convenience functions like \code{hour} and \code{quarter} are -provided to group or extract by hour, month, and other date-time -intervals. \code{as.POSIXlt} is also useful. For example, -\code{as.POSIXlt(x)$mon} is the integer month. The R base convenience -functions \code{weekdays}, \code{months}, and \code{quarters} can also -be used, but these return character values, so they must be converted to -factors for use with data.table. \code{isoweek} is ISO 8601-consistent. - -The \code{round} method for IDate's is useful for grouping and plotting. -It can round to weeks, months, quarters, and years. Similarly, the \code{round} -and \code{trunc} methods for ITime's are useful for grouping and plotting. -They can round or truncate to hours and minutes. -Note for ITime's with 30 seconds, rounding is inconsistent due to rounding off a 5. -See 'Details' in \code{\link{round}} for more information. - -Functions like \code{week()} and \code{isoweek()} provide week numbering functionality. -\code{week()} computes completed or fractional weeks within the year, -while \code{isoweek()} calculates week numbers according to ISO 8601 standards, -which specify that the first week of the year is the one containing the first Thursday. -This convention ensures that week boundaries align consistently with year boundaries, -accounting for both year transitions and varying day counts per week. - -Similarly, \code{isoyear()} returns the ISO 8601 year corresponding to the ISO week. - -} - -\value{ - For \code{as.IDate}, a class of \code{IDate} and \code{Date} with the - date stored as the number of days since some origin. - - For \code{as.ITime}, a class of \code{ITime} - stored as the number of seconds in the day. - - For \code{IDateTime}, a data table with columns \code{idate} and - \code{itime} in \code{IDate} and \code{ITime} format. - - \code{second}, \code{minute}, \code{hour}, \code{yday}, \code{wday}, - \code{mday}, \code{week}, \code{isoweek}, \code{isoyear}, \code{month}, \code{quarter}, - and \code{year} return integer values - for second, minute, hour, day of year, day of week, - day of month, week, month, quarter, and year, respectively. - \code{yearmon} and \code{yearqtr} return double values representing - respectively \code{year + (month-1) / 12} and \code{year + (quarter-1) / 4}. - - \code{second}, \code{minute}, \code{hour} are taken directly from - the \code{POSIXlt} representation. - All other values are computed from the underlying integer representation - and comparable with the values of their \code{POSIXlt} representation - of \code{x}, with the notable difference that while \code{yday}, \code{wday}, - and \code{mon} are all 0-based, here they are 1-based. - -} -\references{ - - G. Grothendieck and T. Petzoldt, \dQuote{Date and Time Classes in R}, - R News, vol. 4, no. 1, June 2004. - - H. Wickham, https://gist.github.com/hadley/10238. - - ISO 8601, https://www.iso.org/iso/home/standards/iso8601.htm -} - -\author{ Tom Short, t.short@ieee.org } - -\seealso{ \code{\link{as.Date}}, \code{\link{as.POSIXct}}, - \code{\link{strptime}}, \code{\link{DateTimeClasses}} - -} - -\examples{ - -# create IDate: -(d <- as.IDate(""2001-01-01"")) - -# S4 coercion also works -identical(as.IDate(""2001-01-01""), methods::as(""2001-01-01"", ""IDate"")) - -# create ITime: -(t <- as.ITime(""10:45"")) - -# S4 coercion also works -identical(as.ITime(""10:45""), methods::as(""10:45"", ""ITime"")) - -(t <- as.ITime(""10:45:04"")) - -(t <- as.ITime(""10:45:04"", format = ""\%H:\%M:\%S"")) - -# ""24:00:00"" is parsed as ""00:00:00"" -as.ITime(""24:00:00"") - -# Workaround for end-of-day: add 1 second to ""23:59:59"" -as.ITime(""23:59:59"") + 1L - -as.POSIXct(""2001-01-01"") + as.ITime(""10:45"") - ---- - -En este caso, la función no exportada `[.data.table` volverá a llamar a `[.data.frame` como medida de protección, ya que `data.table` no tiene forma de saber que el paquete padre es consciente de que está intentando realizar llamadas contra la sintaxis de la API de consulta de `data.table` (lo que podría generar un comportamiento inesperado ya que la estructura de las llamadas a `[.data.frame` y `[.data.table` difieren fundamentalmente, por ejemplo, este último tiene muchos más argumentos). - -Si este es su enfoque preferido para el desarrollo de paquetes, defina `.datatable.aware = TRUE` en cualquier parte de su código fuente de R (no es necesario exportar). Esto indica a `data.table` que usted, como desarrollador de paquetes, ha diseñado su código para que utilice intencionalmente su funcionalidad, aunque no sea evidente al inspeccionar su archivo `NAMESPACE`. - -`data.table` determina sobre la marcha si la función que llama es consciente de que está accediendo a `data.table` con la función interna `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), que, además de verificar `?getNamespaceImports` para su paquete, también verifica la existencia de esta variable (entre otras cosas). - -## Más información sobre las dependencias - -Para obtener documentación más canónica sobre la definición de dependencia de paquetes, consulte el manual oficial: [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html). - -## Importación de rutinas data.table C - -Algunas de las rutinas C utilizadas internamente ahora se exportan a nivel C, por lo que se pueden usar en paquetes R directamente desde su código C. Consulte [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) para obtener detalles y la sección [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) *Enlace a rutinas nativas en otros paquetes* para su uso. - -## Importación desde aplicaciones que no son r {#non-r-api} - -Algunas pequeñas partes del código C de `data.table` se aislaron de la API de RC y ahora pueden usarse desde aplicaciones que no sean de R mediante enlaces a archivos .so o .dll. Más adelante se proporcionarán detalles más concretos al respecto; por ahora, puede estudiar el código C aislado de la API de RC en [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) y [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c). - -## Cómo convertir su dependencia Depends en data.table a Imports - -Para convertir una dependencia `Depends` de `data.table` en una dependencia `Imports` en su paquete, siga estos pasos: - -### Paso 0. Asegúrese de que su paquete pase la verificación R CMD inicialmente - -### Paso 1. Actualice el archivo DESCRIPTION para colocar data.table en Imports, no en Depends - -**Antes:** - -```dcf -Depends: - R (>= 3.5.0), - data.table -Imports: -``` - -**Después:** - -```dcf -Depends: - R (>= 3.5.0) -Imports: - data.table -``` - -### Paso 2.1: Ejecutar `R CMD check` - -Ejecute `R CMD check` para identificar importaciones o símbolos faltantes. Este paso ayuda a: - -- Detecta automáticamente cualquier función o símbolo de `data.table` que no se importe explícitamente. -- Marca los símbolos especiales faltantes como `.N`, `.SD` y `:=`. -- Proporciona retroalimentación inmediata sobre lo que se debe agregar al archivo NAMESPACE. - -Nota: No todos estos usos son detectados por `R CMD check`. En particular, `R CMD check` omite algunos símbolos/funciones en fórmulas y no detecta expresiones analizadas como `parse(text = ""data.table(a = 1)"")`. Los paquetes necesitarán una buena cobertura de pruebas para detectar estos casos extremos. - -### Paso 2.2: Modificar el archivo NAMESPACE - -Según los resultados de `R CMD check`, asegúrese de que se importen todas las funciones utilizadas, los símbolos especiales, los genéricos S3 y las clases S4 de `data.table`. - ---- - -require(methods) -if (exists(""test.data.table"", .GlobalEnv, inherits=FALSE)) { - if ((tt<-compiler::enableJIT(-1))>0) - cat(""This is dev mode and JIT is enabled (level "", tt, "") so there will be a brief pause around the first test.\n"", sep="""") -} else { - require(data.table) - test = data.table:::test - INT = data.table:::INT - colnamesInt = data.table:::colnamesInt - coerceAs = data.table:::coerceAs -} - -sugg = c( - ""bit64"" -) -for (s in sugg) { - assign(paste0(""test_"",s), loaded<-suppressWarnings(suppressMessages( - library(s, character.only=TRUE, logical.return=TRUE, quietly=TRUE, warn.conflicts=FALSE, pos=""package:base"") # attach at the end for #5101 - ))) - if (!loaded) cat(""\n**** Suggested package"",s,""is not installed or has dependencies missing. Tests using it will be skipped.\n\n"") -} - ---- - -14. Passing functions programmatically with `env=` doesn't produce an opaque error, e.g. `DT[, f(b), env = list(f=sum)]`, [#6026](https://github.com/Rdatatable/data.table/issues/6026). Note that it's much better to pass functions like `f=""sum""` instead. Thanks to @MichaelChirico for the bug report and fix. - -### NOTES - -1. `transform()` method for data.table sped up substantially when creating new columns on large tables. Thanks to @OfekShilon for the report and PR. The implemented solution was proposed by @ColeMiller1. - -2. The documentation for the `fill` argument in `rbind()` and `rbindlist()` now notes the expected behaviour for missing `list` columns when `fill=TRUE`, namely to use `NULL` (not `NA`), [#4198](https://github.com/Rdatatable/data.table/pull/4198). Thanks @sritchie73 for the proposal and fix. - -3. data.table now depends on R 3.3.0 (2016) instead of 3.1.0 (2014). Recent versions of R have good features that we would gradually like to incorporate, and we see next to no usage of these very old versions of R. We originally attempted to bump only to R 3.2.0 in this release, but our vignette engine {knitr} requiring 3.3.0 and `R CMD check` lacking an `--ignore-vignettes` option until 3.3.0 essentially forced our hands. - -4. Erroneous assignment calls in `[` with a trailing comma (e.g. ``DT[, `:=`(a = 1, b = 2,)]``) get a friendlier error since this situation is common during refactoring and easy to miss visually. Thanks @MichaelChirico for the fix. - -5. Input files are now kept open during `mmap()` when running under Emscripten, [emscripten-core/emscripten#20459](https://github.com/emscripten-core/emscripten/issues/20459). This avoids an error in `fread()` when running in WebAssembly, [#5969](https://github.com/Rdatatable/data.table/issues/5969). Thanks to @maek-ies for the report and @georgestagg for the PR. - -6. `dcast()` improves behavior for the situation that the `fun.aggregate` value of `length()` is used but not provided by the user. - - a. This now triggers a warning, not a message, since relying on this default often signals unexpected duplicates in the data, [#5386](https://github.com/Rdatatable/data.table/issues/5386). The warning is classed as `dt_missing_fun_aggregate_warning`, allowing for more targeted handling in user code. Thanks @MichaelChirico for the suggestion and @Nj221102 for the fix. - - b. The warning itself does better explaining the behavior and suggesting alternatives, [#5217](https://github.com/Rdatatable/data.table/issues/5217). Thanks @MichaelChirico for the suggestion and @Nj221102 for the fix. - -7. Updated a test relying on operator `>` working for comparing language objects to a string, which will be deprecated by R, [#5977](https://github.com/Rdatatable/data.table/issues/5977); no user-facing effect. Thanks to R-core for continuously improving the language. - -8. Improved OpenMP detection when building from source on Mac, [#4348](https://github.com/Rdatatable/data.table/issues/4348). Thanks @jameshester and @kevinushey for the request and @kevinushey for the PR, @jameslamb for the advice and @s-u of R-core for ensuring CRAN machines are configured to support the expected setup. - -9. `test.data.table()` runs more robustly: - - a. In sessions where the `digits` or `warn` options are not their defaults (`7` and `0`, respectively), [#5285](https://github.com/Rdatatable/data.table/issues/5285). Thanks @OfekShilon for the report and suggested fix and @MichaelChirico for the PR. - - b. In locales where `letters != sort(letters)`, e.g. Latvian, [#3502](https://github.com/Rdatatable/data.table/issues/3502). Thanks @minemR for the report and @MichaelChirico for the fix. - ---- - -* gains argument `strip.white` which is `TRUE` by default (unlike `base::read.table`). All unquoted columns' leading and trailing white spaces are automatically removed. If \code{FALSE}, only trailing spaces of header is removed. Closes [#1113](https://github.com/Rdatatable/data.table/issues/1113), [#1035](https://github.com/Rdatatable/data.table/issues/1035), [#1000](https://github.com/Rdatatable/data.table/issues/1000), [#785](https://github.com/Rdatatable/data.table/issues/785), [#529](https://github.com/Rdatatable/data.table/issues/529) and [#956](https://github.com/Rdatatable/data.table/issues/956). Thanks to @dmenne, @dpastoor, @GHarmata, @gkalnytskyi, @renqian, @MatthewForrest, @fxi and @heraldb. - * doesn't warn about empty lines when 'nrow' argument is specified and that many rows are read properly. Thanks to @richierocks for the report. Closes [#1330](https://github.com/Rdatatable/data.table/issues/1330). - * doesn't error/warn about not being able to read last 5 lines when 'nrow' argument is specified. Thanks to @robbig2871. Closes [#773](https://github.com/Rdatatable/data.table/issues/773). - ---- - -require(data.table) -test.data.table(script=""types.Rraw"") - ---- - -#: data.table.R:1225 -#, c-format -msgid """" -""A shallow copy of this data.table was taken so that := can add or remove %d "" -""columns by reference. At an earlier point, this data.table was copied by R "" -""(or was created manually using structure() or similar). Avoid names<- and "" -""attr<- which in R currently (and oddly) may copy the whole data.table. Use "" -""set* syntax instead to avoid copying: ?set, ?setnames and ?setattr. It's "" -""also not unusual for data.table-agnostic packages to produce tables affected "" -""by this issue. If this message doesn't help, please report your use case to "" -""the data.table issue tracker so the root cause can be fixed or this message "" -""improved."" -msgstr """" -""Une copie (shallow) du data.table a été utilisée afin que := puisse ajouter "" -""ou supprimer %d colonnes par référence. Ce data.table a été copié "" -""antérieurement par R (ou a été créé manuellement en utilisant structure() ou "" -""similaire). Évitez names<- et attr<- qui, dans R, peuvent actuellement (et "" -""bizarrement) copier tout le data.table. Utilisez plutôt la syntaxe set* à la "" -""place pour éviter la copie : ?set, ?setnames et ?setattr. Il est aussi "" -""fréquent que les packages qui ne reconnaissent pas les data.tables génèrent "" -""des tables concernées par ce problème. Si ce message ne vous aide pas, "" -""veuillez rapporter votre cas d'utilisation dans le gestionnaire de tickets "" -""de data.table (issue tracker) afin que la cause première puisse être "" -""corrigée ou que ce message soit amélioré."" - -#: data.table.R:1285 -#, c-format -msgid """" -""Variable '%s' is not found in calling scope. Looking in calling scope "" -""because this symbol was prefixed with .. in the j= parameter."" -msgstr """" -""La variable '%s' n'est pas visible dans le contexte de l'appelant désigné "" -""par le préfixe .. du symbole dans le paramètre j= ."" - -#: data.table.R:1358 -#, c-format -msgid """" -""j (the 2nd argument inside [...]) is a single symbol but column name '%1$s' "" -""is not found. If you intended to select columns using a variable in calling "" -""scope, please try DT[, ..%1$s]. The .. prefix conveys one-level-up similar "" -""to a file system path."" -msgstr """" -""j (le deuxième argument à l'intérieur de [...]) est un symbole unique mais "" -""le nom de la colonne '%1$s' n'est pas trouvé. Si vous souhaitez sélectionner "" -""des colonnes à l'aide d'une variable dans la portée de l'appelant, essayez "" -""DT[, ..%1$s]. Le préfixe .. indique un niveau supérieur similaire à celui "" -""d'un chemin d'accès pour un système de fichiers."" - -#: data.table.R:1408 -msgid """" -""Growing vector of column pointers from truelength %d to %d. A shallow copy "" -""has been taken, see ?setalloccol. Only a potential issue if two variables "" -""point to the same data (we can't yet detect that well) and if not you can "" -""safely ignore this. To avoid this message you could setalloccol() first, "" -""deep copy first using copy(), wrap with suppressWarnings() or increase the "" -""'datatable.alloccol' option."" -msgstr """" -""Vecteur croissant des pointeurs de colonnes de truelength %d à %d. Une copie "" -""(shallow) a été faite, voir ?setalloccol. Il reste seulement un problème "" -""potentiel quand deux variables pointent sur les mêmes données (il n'est pas "" -""encore possible de détecter cela correctement) mais vous pouvez l'ignorer si "" -""ce n'est pas le cas. Pour éviter ce message utilisez d'abord setalloccol(), "" -""puis copiez le tout avec copy(), encadrez avec suppressWarnings() ou "" -""augmentez l'option 'datatable.alloccol'."" - -#: data.table.R:1410 -msgid """" -""Note that the shallow copy will assign to the environment from which := was "" -""called. That means for example that if := was called within a function, the "" -""original table may be unaffected."" -msgstr """" -""Noter que la copie (shallow) sera fonction de l'environnement dans lequel := "" -""a été appelé. Ce qui signifie par exemple que si := est appelé d'une "" -""fonction, il est possible que la table originale ne soit pas modifiée."" - ---- - -Using Regular Expressions and the nc Package Toby Dylan Hocking 2021.05 Update about data reshaping and visualization in R and python Toby Dylan Hocking 2021.05 Hamburg RUG: A professional trading research system in R Daniel Brandt 2021.05 The new R pipe Elio Campitelli 2021.04 10 Tips And Tricks For Data Scientists Vol.6 George Pipis 2021.04 Not data.table vs dplyr... data.table + dplyr! Matt Dancho 2021.03 Some data.table tips John MacKintosh 2021.03 Data.Table – everything you need to know to get you started in R Gary Hutson 2021.02 I wrote one of the fastest DataFrame libraries (hacker news) Ritchie Vink 2021.02 Joins vs case whens - speed and memory tradeoffs Thomas Mock 2021.02 The unequalled joy of non-equi joins David Selby 2021.02 Measuring and Monitoring Arrow's Performance: Some Updated R Benchmarks (response) Jonathan Keane & Neal Richardson 2021.02 Bigger Data With Ease Using Apache Arrow, (response) (rebuttal) Neal Richardson 2021.01 Fast and Easy Aggregation of Multi-Type and Survey Data in R Sebastian Krantz 2021.01 How to create a stock screener Martin Bel 2020.12 You only need library(data.table) / 你只需要 library(data.table) (in Chinese) Xianying Tan (@shrektan) 2020.11 Comparing Common Operations in dplyr and data.table Martin Chan 2020.11 non-equi merge in data.table and epidemiology Denis Mongin 2020.10 The ultimate R data.table cheat sheet Sharon Machlis 2020.10 What is R data.table and Why is R data.table? (In Korean, 한국어) HongDon Lee 2020.10 Solving small problems with data.table John MacKintosh 2020.10 Python and R – Part 1: Exploring Data with Datatable David Lucey 2020.10 Decomposition and Smoothing with data.table, reticulate, and spatstat Tony ElHabr 2020.09 The Fastest Way To Read And Write Files In R George Pipis 2020.09 The treedata.table Package April Wright, Cristian Román-Palacios, Josef Uyeda 2020.09 Gotta go fast with ""{tidytable}"" Bruno Rodrigues 2020.09 Task 2 - Retail Strategy and Analytics Shrishti Vaish 2020.08 Solving small data problems with data.table John MacKintosh 2020.08 Replicating .SD in Python Datatable Samuel Oranyeli 2020.08 Let's Learn data.table (日本語) Uryu Shinya 2020.08 87th TokyoR Meetup Roundup: {data.table}, Bioconductor, & more! Ryo Nakagawara 2020.07 5 handy options in R data.table’s fread Sharon Machlis 2020.07 Even more reshape benchmarks Grant McDermott 2020.07 RvsPython #2: Pivoting Data From Long to Wide Form Benjamin Smith 2020.06 A gentle introduction to data.table @atrebas 2020.06 Reshape benchmarks Grant McDermott 2020.06 Selecting and Grouping Data with Python Datatable Samuel Oranyeli 2020.05 dtplyr speed benchmarks Iyar Lin 2020.05 Creating a data.table from C++ David Zimmermann, Leonardo Silvestri, Dirk Eddelbuettel 2020.04 Data manipulation libraries: Translating between data.table, pandas, dplyr Toby Dylan Hocking 2020.04 patientcounter John MacKintosh 2020.04 Fastest data operations with least memory in tidy syntax Tian-Yuan Huang 2020.04 W is for Write and Read Data – Fast Sara Locatelli 2020.03 Use data.table the tidy way: An ultimate tutorial of tidyfst Tian-Yuan Huang 2020.03 R data.table symbols and operators you should know Sharon Machlis 2020.03 Variable name in functions, it's easy with datatable Lino Galiana 2020.02 stringsAsFactors Kurt Hornik 2020.01 Programming with data.table John MacKintosh 2020.01 Blazing Fast Data Wrangling With R data.table Thu Vu 2020.01 New Timings for a Grouped In-Place Aggregation Task John Mount 2020.01 Base R, the tidyverse, and data.table: a comparison of R dialects to wrangle your data Jason Mercer 2019.12 4 great free tools that can make your R work more efficient, reproducible and robust Jozef Hajnala 2019.12 Why I don’t use the Tidyverse Holger K. von Jouanne-Diedrich 2019.11 dtplyr 1.0.0 Hadley Wickham 2019.10 Using ggplot2 Inside data.table John Lashlee 2019.10 Fast and Readable 'If Else' in R Tysson Barrett 2019.10 Data Joins: Speed and Efficiency of dplyr and data.table Tysson Barrett 2019.10 Comparing - ---- - -/* This header file provides the interface used by other packages, - and should be included once per package. */ - -#ifndef _R_data_table_API_h_ -#define _R_data_table_API_h_ - -/* number of R header files (possibly listing too many) */ -#include - -#ifdef HAVE_VISIBILITY_ATTRIBUTE - # define attribute_hidden __attribute__ ((visibility (""hidden""))) -#else - # define attribute_hidden -#endif - -#ifdef __cplusplus -extern ""C"" { -#endif - -/* provided the interface for the function exported in - ../src/init.c via R_RegisterCCallable() */ - -// subsetDT #3751 -inline SEXP attribute_hidden DT_subsetDT(SEXP x, SEXP rows, SEXP cols) { - static SEXP(*fun)(SEXP, SEXP, SEXP) = - (SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable(""data.table"", ""DT_subsetDT""); - return fun(x,rows,cols); -} -// forder #4015 -// setalloccol alloccolwrapper setDT #4439 - -/* permit opt-in to redefine shorter identifiers */ -#if defined(DATATABLE_REMAP_API) - #define subsetDT DT_subsetDT -#endif - -#ifdef __cplusplus -} - -/* add a namespace for C++ use */ -namespace dt { - inline SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { return DT_subsetDT(x, rows, cols); } -} - -#endif /* __cplusplus */ - -#endif /* _R_data_table_API_h_ */ - ---- - -9. `DT[1, on=NULL]` now works for returning the first row, [#6579](https://github.com/Rdatatable/data.table/issues/6579). Thanks to @Kodiologist for the report and @tdhock for the PR. - -10. `tables()` now returns the correct size for data.tables over 2GiB, [#6607](https://github.com/Rdatatable/data.table/issues/6607). Thanks to @vlulla for the report and the PR. - -11. `rbindlist(l, use.names=TRUE)` can now handle different encodings for the column names in different entries of `l`, [#5452](https://github.com/Rdatatable/data.table/issues/5452). Thanks to @MEO265 for the report, and Benjamin Schwendinger for the fix. - -12. Added a `data.frame` method for `format_list_item()` to fix error printing data.tables with columns containing 1-column data.frames, [#6592](https://github.com/Rdatatable/data.table/issues/6592). Thanks to @r2evans for the bug report and fix. - -13. Auto-printing gets some substantial improvements - - Suppression in `knitr` documents is now done by implementing a method for `knit_print` instead of looking up the call stack, [#6589](https://github.com/Rdatatable/data.table/pull/6589). The old way was fragile and wound up broken by some implementation changes in {knitr}. Thanks to @jangorecki for the report [#6509](https://github.com/Rdatatable/data.table/issues/6509) and @aitap for the fix. - - `print()` methods for S3 subclasses of data.table (e.g. an object of class `c(""my.table"", ""data.table"", ""data.frame"")`) no longer print where plain data.tables wouldn't, e.g. `myDT[, y := 2]`, [#3029](https://github.com/Rdatatable/data.table/issues/3029). The improved detection of auto-printing scenarios has the added benefit of _allowing_ print in highly explicit statements like `print(DT[, y := 2])`, obviating our recommendation since v1.9.6 to append `[]` to signal ""please print me"". - -14. Joins of `integer64` and `double` columns succeed when the `double` column has lossless `integer64` representation, [#4167](https://github.com/Rdatatable/data.table/issues/4167) and [#6625](https://github.com/Rdatatable/data.table/issues/6625). Previously, this only worked when the double column had lossless _32-bit_ integer representation. Thanks @MichaelChirico for the reports and fix. - -15. `DT[order(...)]` better matches `base::order()` behavior by (1) recognizing the `method=` argument (and erroring since this is not supported) and (2) accepting a vector of `TRUE`/`FALSE` in `decreasing=` as an alternative to using `-a` to convey ""sort `a` decreasing"", [#4456](https://github.com/Rdatatable/data.table/issues/4456). Thanks @jangorecki for the FR and @MichaelChirico for the PR. - -16. Assignment with `:=` to an S4 slot of an under-allocated data.table now works, [#6704](https://github.com/Rdatatable/data.table/issues/6704). Thanks @MichaelChirico for the report and fix. - -17. `as.data.table()` method for `data.frame`s (especially those with extended classes) is more consistent with `as.data.frame()` with respect to rention of attributes, [#5699](https://github.com/Rdatatable/data.table/issues/5699). Thanks @jangorecki for the report and fix. - -18. Grouped queries on keyed tables no longer return an incorrectly keyed result if the _ad hoc_ `by=` list has some function call (in particular, a function which happens to return a strictly decreasing function of the keys), e.g. `by=.(a = rev(a))`, [#5583](https://github.com/Rdatatable/data.table/issues/5583). Thanks @AbrJA for the report and @MichaelChirico for the fix. - -19. An integer overflow in `fread()` with lines longer than `2^(31/2)` bytes is prevented, [#6729](https://github.com/Rdatatable/data.table/issues/6729). The typical impact was no worse than a wrong initial allocation size, corrected later. Thanks to @TaikiSan21 for the report and @aitap for the fix. - -20. Fixed a memory issue causing segfaults in `forder`, [#6797](https://github.com/Rdatatable/data.table/issues/6797). Thanks @dkutner for the report and @MichaelChirico for the fix. - ---- - -### BUG FIXES - -1. `fwrite()` respects `dec=','` for timestamp columns (`POSIXct` or `nanotime`) with sub-second accuracy, [#6446](https://github.com/Rdatatable/data.table/issues/6446). Thanks @kav2k for pointing out the inconsistency and @MichaelChirico for the PR. - -2. The data.table-only attribute `$.internal.selfref` is no longer set for data.frames. [#5286](https://github.com/Rdatatable/data.table/issues/5286). Thanks @OfekShilon for the report and fix. - -3. Tagging/naming arguments of `c()` in `j=c()` should now more closely follow base R conventions for concatenation of named lists during grouping, [#2311](https://github.com/Rdatatable/data.table/issues/2311). Naming an `lapply(.SD, FUN)` call as an argument of `c()` in `j` will now always cause that tag to get prepended (with a single dot separator) to the resulting column names. Additionally, naming a `list()` call as an argument of `c()` in `j` will now always cause that tag to get prepended to any names specified within the list call. This bug only affected queries with (1) `by=` grouping (2) `getOption(""datatable.optimize"") >= 1L` and (3) `lapply(.SD, FUN)` in `j`. - - While the names returned by `data.table` when `j=c()` will now mostly follow base R conventions for concatenating lists, note that names which are completely unspecified will still be named positionally, matching the typical behavior in `j` and `data.table()`. according to position in `j` (e.g. `V1`, `V2`). - - Thanks to @franknarf1 for reporting and @myoung3 for the PR. - - ```r - # tag 'mean' prepended to lapply()-named columns - names(mtcars[, c(mean=lapply(.SD,sum)), by=""cyl"", .SDcols=c(""am"", ""carb"")]) - # [1] ""cyl"" ""mean.am"" ""mean.carb"" - - # tag 'mean' is prepended to the first named sublist, 'sum' to the second - names(mtcars[, c(mean=list(a=mean(hp), b=mean(wt)), sum=lapply(.SD, sum)), by=""cyl"", .SDcols=c(""am"", ""carb"")]) - # [1] ""cyl"" ""mean.a"" ""mean.b"" ""sum.am"" ""sum.carb"" - - # strict base naming would result in names c("""", ""b"", ""c"") here - names(mtcars[, c(list(mean(hp), b=mean(wt)), c=list(mean(cyl)))]) - # [1] ""V1"" ""b"" ""c"" - ``` - -4. Queries like `DT[, min(x):max(x)]` now work as expected, i.e. the same as `DT[, seq(min(x), max(x))]` or `with(DT, min(x):max(x))`, [#2069](https://github.com/Rdatatable/data.table/issues/2069). Shorthand like `DT[, a:b]` meaning ""select from columns `a` through `b`"" still works. Thanks to @franknarf1 for reporting, @jangorecki for the fix, and @MichaelChirico for follow-ups ensuring back-compatibility. - -5. `fread()` performance improves when specifying `Date` among `colClasses`, [#6105](https://github.com/Rdatatable/data.table/issues/6105). One implication of the change is that the column will be an `IDate` (which also inherits from `Date`), which may affect code strongly relying on the column class to be `Date` exactly; computations with `IDate` and `Date` columns should otherwise be the same. If you strongly prefer the `Date` class, run `as.Date()` explicitly following `fread()`. Thanks @scipima for the report and @MichaelChirico for the fix. - -6. `dt[, col]` now returns a copy of `col` also when it is a list column, as in any other case, [#4877](https://github.com/Rdatatable/data.table/issues/4877). Thanks to @tlapak for reporting and the PR. - -7. `rbindlist` and `rbind` binding `bit64::integer64` columns with `character`/`complex`/`list` columns now works, [#5504](https://github.com/Rdatatable/data.table/issues/5504). Thanks to @MichaelChirico for the request and @ben-schwen for the PR. - -8. Fixed possible segfault in `setDT(df); attr(df, key) <- value; set(df, ...)`, i.e. adding columns to an object with `set()` that was converted to data.table with `setDT()` and later had attributes add with `attr<-`, [#6410](https://github.com/Rdatatable/data.table/issues/6410). Thanks to @hongyuanjia for the report and @ben-schwen for the PR. Note that `setattr()` should be preferred for adding attributes to a data.table. - ---- - -# one and two+ row cases of data.table, as.data.table and cbind involving list columns, given -# the change to tests 1613.571-3 in PR#3471 in v1.12.4 -# in v1.12.2 and before : -# data.table( data.table(1:2), list(c(""a"",""b""),""a"") ) -# V1 V2 NA -# -# 1: 1 a a -# 2: 2 b a -# i.e. passing a data.table() to data.table() changed the meaning of list() which was inconsistent, -# and an NA column name was introduced too (a bug in itself) -# from v1.12.4 : -# V1 V2 -# -# 1: 1 a,b -# 2: 2 a -# i.e. now easier to add the list column as intended, and it's consistent with -# basic (i.e. not cbind-like) usage of data.table() -# # changed in v1.12.4 ? -ans = data.table(V1=1, V2=2) # -------------------- -test(2058.01, data.table( data.table(1), 2), ans) # no -test(2058.02, as.data.table(list(data.table(1), 2)), ans) # no -test(2058.03, cbind(data.table(1), 2), ans) # no -ans = data.table(V1=1, V2=list(2)) # 'basic' usage; i.e. not cbind-like -test(2058.04, sapply(ans, class), c(V1=""numeric"", V2=""list"")) # no -test(2058.05, data.table( data.table(1), list(2) ), ans) # yes -test(2058.06, as.data.table(list(data.table(1), list(2))), ans) # yes -test(2058.07, cbind(data.table(1), list(2)), ans) # yes -ans = data.table(V1=1:2, V2=list(c(""a"",""b""),""a"")) -test(2058.08, sapply(ans, class), c(V1=""integer"", V2=""list"")) # no -test(2058.09, data.table( data.table(1:2), list(c(""a"",""b""),""a"") ), ans) # yes -test(2058.10, as.data.table(list(data.table(1:2), list(c(""a"",""b""),""a""))), ans) # yes -test(2058.11, cbind(data.table(1:2), list(c(""a"",""b""),""a"")), ans) # yes -test(2058.12, cbind(first=data.table(A=1:3), second=data.table(A=4, B=5:7)), - data.table(first.A=1:3, second.A=4, second.B=5:7)) # no -test(2058.13, cbind(data.table(A=1:3), second=data.table(A=4, B=5:7)), - data.table(A=1:3, second.A=4, second.B=5:7)) # no -test(2058.14, cbind(data.table(A=1,B=2),3), data.table(A=1,B=2,V2=3)) # no -L = list(1:3, 4:6) -test(2058.15, as.data.table(L), data.table(V1=1:3, V2=4:6)) # no -# retain all-blank list names as batchtools relies on in reg$defs[1,job.pars], #3581 -names(L) = c("""","""") -test(2058.16, as.data.table(L), setnames(data.table(1:3, 4:6),c("""",""""))) # no -# retain existing duplicate and blank names of a plain-list, just as 1.12.2 did -L = list(1:3, 4:6, 7:9, 10:12) -names(L) = c("""",""foo"","""",""foo"") -test(2058.17, as.data.table(L), - setnames(data.table(1:3, 4:6, 7:9, 10:12),c("""",""foo"","""",""foo""))) # no -L = list(1:3, NULL, 4:6) -test(2058.18, length(L), 3L) -test(2058.19, as.data.table(L), data.table(V1=1:3, V2=4:6)) # V2 not V3 # no -DT = data.table(a=1:3, b=c(4,5,6)) -test(2058.20, DT[,b:=list(NULL)], data.table(a=1:3)) # no - ---- - ---- -title: ""Programming on data.table"" -date: ""`{r} Sys.Date()`"" -output: - litedown::html_format -vignette: > - %\VignetteIndexEntry{Programming on data.table} - %\VignetteEngine{litedown::vignette} - \usepackage[utf8]{inputenc} ---- - -```{r, echo=FALSE, file='_translation_links.R'} -``` -`{r} .write.translation.links(""Translations of this document are available in: %s"")` - -```{r init, include = FALSE} -require(data.table) -litedown::reactor(comment = ""# "") -``` - -## Introduction - -`data.table`, from its very first releases, enabled the usage of `subset` and `with` (or `within`) functions by defining the `[.data.table` method. `subset` and `with` are base R functions that are useful for reducing repetition in code, enhancing readability, and reducing number the total characters the user has to type. This functionality is possible in R because of a quite unique feature called *lazy evaluation*. This feature allows a function to catch its arguments, before they are evaluated, and to evaluate them in a different scope than the one in which they were called. Let's recap usage of the `subset` function. - -```{r df_print, echo=FALSE} -registerS3method(""print"", ""data.frame"", function(x, ...) { - base::print.data.frame(head(x, 2L), ...) - cat(""...\n"") - invisible(x) -}) -.opts = options( - datatable.print.topn=2L, - datatable.print.nrows=20L -) -``` - -```{r subset} -subset(iris, Species == ""setosa"") -``` - -Here, `subset` takes the second argument and evaluates it within the scope of the `data.frame` given as its first argument. This removes the need for variable repetition, making it less prone to errors, and makes the code more readable. - -## Problem description - -The problem with this kind of interface is that we cannot easily parameterize the code that uses it. This is because the expressions passed to those functions are substituted before being evaluated. - -### Example - -```{r subset_error, error=TRUE, purl=FALSE} -my_subset = function(data, col, val) { - subset(data, col == val) -} -my_subset(iris, Species, ""setosa"") -``` - -### Approaches to the problem - -There are multiple ways to work around this problem. - -#### Avoid *lazy evaluation* - -The easiest workaround is to avoid *lazy evaluation* in the first place, and fall back to less intuitive, more error-prone approaches like `df[[""variable""]]`, etc. - -```{r subset_nolazy} -my_subset = function(data, col, val) { - data[data[[col]] == val & !is.na(data[[col]]), ] -} -my_subset(iris, col = ""Species"", val = ""setosa"") -``` - -Here, we compute a logical vector of length `nrow(iris)`, then this vector is supplied to the `i` argument of `[.data.frame` to perform ordinary ""logical vector""-based subsetting. To align with `subset()`, which also drops NAs, we need to include an additional use of `data[[col]]` to catch that. It works well enough for this simple example, but it lacks flexibility, introduces variable repetition, and requires user to change the function interface to pass the column name as a character rather than unquoted symbol. The more complex the expression we need to parameterize, the less practical this approach becomes. - -#### Use of `parse` / `eval` - -This method is usually preferred by newcomers to R as it is, perhaps, the most straightforward conceptually. This way requires producing the required expression using string concatenation, parsing it, and then evaluating it. - -```{r subset_parse} -my_subset = function(data, col, val) { - data = deparse(substitute(data)) - col = deparse(substitute(col)) - val = paste0(""'"", val, ""'"") - text = paste0(""subset("", data, "", "", col, "" == "", val, "")"") - eval(parse(text = text)[[1L]]) -} -my_subset(iris, Species, ""setosa"") -``` - -We have to use `deparse(substitute(...))` to catch the actual names of objects passed to function, so we can construct the `subset` function call using those original names. Although this provides unlimited flexibility with relatively low complexity, **use of `eval(parse(...))` should be avoided**. The main reasons are: - ---- - -## Can base be changed to do this then, rather than a new package? -`data.frame` is used _everywhere_ and so it is very difficult to make _any_ changes to it. -data.table _inherits_ from `data.frame`. It _is_ a `data.frame`, too. A data.table _can_ be passed to any package that _only_ accepts `data.frame`. When that package uses `[.data.frame` syntax on the data.table, it works. It works because `[.data.table` looks to see where it was called from. If it was called from such a package, `[.data.table` diverts to `[.data.frame`. - -## I've heard that data.table syntax is analogous to SQL. -Yes: - - - `i` $\Leftrightarrow$ where - - `j` $\Leftrightarrow$ select - - `:=` $\Leftrightarrow$ update - - `by` $\Leftrightarrow$ group by - - `i` $\Leftrightarrow$ order by (in compound syntax) - - `i` $\Leftrightarrow$ having (in compound syntax) - - `nomatch = NA` $\Leftrightarrow$ outer join - - `nomatch = NULL` $\Leftrightarrow$ inner join - - `mult = ""first""|""last""` $\Leftrightarrow$ N/A because SQL is inherently unordered - - `roll = TRUE` $\Leftrightarrow$ N/A because SQL is inherently unordered - -The general form is: - -```r -DT[where, select|update, group by][order by][...] ... [...] -``` - -A key advantage of column vectors in R is that they are _ordered_, unlike SQL[^2]. We can use ordered functions in `data.table` queries such as `diff()` and we can use _any_ R function from any package, not just the functions that are defined in SQL. A disadvantage is that R objects must fit in memory, but with several R packages such as `ff`, `bigmemory`, `mmap` and `indexing`, this is changing. - -[^2]: It may be a surprise to learn that `select top 10 * from ...` does _not_ reliably return the same rows over time in SQL. You do need to include an `order by` clause, or use a clustered index to guarantee row order; _i.e._, SQL is inherently unordered. - -## What are the smaller syntax differences between `data.frame` and data.table {#SmallerDiffs} - ---- - -```{r test_id, message=FALSE, results=""show"", echo=TRUE, warning=FALSE} -require(data.table) # print? -DT = data.table(x=1:3, y=4:6) # no -DT # yes -DT[, z := 7:9] # no -print(DT[, z := 10:12]) # yes -if (1 < 2) DT[, a := 1L] # no -DT # yes -``` -Some text. - ---- - -20. `!` at the head of the expression will no longer trigger a not-join if the expression is logical, #4650. Thanks to Arunkumar Srinivasan for reporting. - - 21. `rbindlist` now chooses the highest type per column, not the first, #2456. Up-conversion follows R defaults, with the addition of factors being the highest type. Also fixes #4981 for the specific case of `NA`'s. - - 22. `cbind(x,y,z,...)` now creates a data.table if `x` isn't a `data.table` but `y` or `z` is, unless `x` is a `data.frame` in which case a `data.frame` is returned (use `data.table(DF,DT)` instead for that). - - 23. `cbind(x,y,z,...)` and `data.table(x,y,z,...)` now retain keys of any `data.table` inputs directly (no sort needed, for speed). The result's key is `c(key(x), key(y), key(z), ...)`, provided, that the data.table inputs that have keys are not recycled and there are no ambiguities (i.e. duplicates) in column names. - - 24. `rbind/rbindlist` will preserve ordered factors if it's possible to do so; i.e., if a compatible global order exists, #4856 & #5019. Otherwise the result will be a `factor` and a *warning*. - - 25. `rbind` now has a `fill` argument, #4790. When `fill=TRUE` it will behave in a manner similar to plyr's `rbind.fill`. This option is incompatible with `use.names=FALSE`. Thanks to Arunkumar Srinivasan for the base code. - - 26. `rbind` now relies exclusively on `rbindlist` to bind `data.tables` together. This makes rbind'ing factors faster, #2115. - - 27. `DT[, as.factor('x'), with=FALSE]` where `x` is a column in `DT` is now equivalent to `DT[, ""x"", with=FALSE]` instead of ending up with an error, #4867. Thanks to tresbot for reporting [here on SO](https://stackoverflow.com/questions/18525976/converting-multiple-data-table-columns-to-factors-in-r). - - 28. `format.data.table` now understands 'formula' and displays embedded formulas as expected, FR #2591. - - 29. `{}` around `:=` in `j` now obtain desired result, but with a warning #2496. Now, - ```R - DT[, { `:=`(...)}] # now works - DT[, {`:=`(...)}, by=(...)] # now works - ``` - Thanks to Alex for reporting [here on SO](https://stackoverflow.com/questions/14541959/expression-syntax-for-data-table-in-r). - - 30. `x[J(2), a]`, where `a` is the key column sees `a` in `j`, #2693 and FAQ 2.8. Also, `x[J(2)]` automatically names the columns from `i` using the key columns of `x`. In cases where the key columns of `x` and `i` are identical, i's columns can be referred to by using `i.name`; e.g., `x[J(2), i.a]`. Thanks to mnel and Gabor for the discussion on datatable-help. - - 31. `print.data.table` gains `row.names`, default=TRUE. When FALSE, the row names (along with the :) are not printed, #5020. Thanks to Frank Erickson. - - 32. `.SDcols` now is also able to de-select columns. This works both with column names and column numbers. - ```R - DT[, lapply(.SD,...), by=..., .SDcols=-c(1,3)] # .SD all but columns 1 and 3 - DT[, lapply(.SD,...), by=..., .SDcols=-c(""x"", ""z"")] # .SD all but columns 'x' and 'z' - DT[..., .SDcols=c(1, -3)] # can't mix signs, error - DT[, .SD, .SDcols=c(""x"", -""z"")] # can't mix signs, error - ``` - Thanks to Tonny Peterson for filing FR #4979. - - 33. `as.data.table.list` now issues a warning for those items/columns that result in a remainder due to recycling, #4813. `data.table()` also now issues a warning (instead of an error previously) when recycling leaves a remainder; e.g., `data.table(x=1:2, y=1:3)`. - - 34. `:=` now coerces without warning when precision is not lost and `length(RHS) == 1`, #2551. - ```R - DT = data.table(x=1:2, y=c(TRUE, FALSE)) - DT[1, x:=1] # ok, now silent - DT[1, y:=0] # ok, now silent - DT[1, y:=0L] # ok, now silent - ``` - - 35. `as.data.table.*(x, keep.rownames=TRUE)`, where `x` is a named vector now adds names of `x` into a new column with default name `rn`. Thanks to Garrett See for FR #2356. - ---- - -8. Compiler support for OpenMP is now detected during installation, which allows `data.table` to compile from source (in single threaded mode) on macOS which, frustratingly, does not include OpenMP support by default, [#2161](https://github.com/Rdatatable/data.table/issues/2161), unlike Windows and Linux. A helpful message is emitted during installation from source, and on package startup as before. Many thanks to @jimhester for the PR. - -9. `rbindlist` now supports columns of type `expression`, [#546](https://github.com/Rdatatable/data.table/issues/546). Thanks @jangorecki for the report. - -10. The dimensions of objects in a `list` column are now displayed, [#3671](https://github.com/Rdatatable/data.table/issues/3671). Thanks to @randomgambit for the request, and Tyson Barrett for the PR. - -11. `frank` gains `ties.method='last'`, paralleling the same in `base::order` which has been available since R 3.3.0 (April 2016), [#1689](https://github.com/Rdatatable/data.table/issues/1689). Thanks @abudis for the encouragement to accommodate this. - -12. The `keep.rownames` argument in `as.data.table.xts` now accepts a string, which can be used for specifying the column name of the index of the xts input, [#4232](https://github.com/Rdatatable/data.table/issues/4232). Thanks to @shrektan for the request and the PR. - -13. New symbol `.NGRP` available in `j`, [#1206](https://github.com/Rdatatable/data.table/issues/1206). `.GRP` (the group number) was already available taking values from `1` to `.NGRP`. The number of groups, `.NGRP`, might be useful in `j` to calculate a percentage of groups processed so far, or to do something different for the last or penultimate group, for example. - -14. Added support for `round()` and `trunc()` to extend functionality of `ITime`. `round()` and `trunc()` can be used with argument units: ""hours"" or ""minutes"". Thanks to @JensPederM for the suggestion and PR. - -15. A new throttle feature has been introduced to speed up small data tasks that are repeated in a loop, [#3175](https://github.com/Rdatatable/data.table/issues/3175) [#3438](https://github.com/Rdatatable/data.table/issues/3438) [#3205](https://github.com/Rdatatable/data.table/issues/3205) [#3735](https://github.com/Rdatatable/data.table/issues/3735) [#3739](https://github.com/Rdatatable/data.table/issues/3739) [#4284](https://github.com/Rdatatable/data.table/issues/4284) [#4527](https://github.com/Rdatatable/data.table/issues/4527) [#4294](https://github.com/Rdatatable/data.table/issues/4294) [#1120](https://github.com/Rdatatable/data.table/issues/1120). The default throttle of 1024 means that a single thread will be used when nrow<=1024, two threads when nrow<=2048, etc. To change the default, use `setDTthreads(throttle=)`. Or use the new environment variable `R_DATATABLE_THROTTLE`. If you use `Sys.setenv()` in a running R session to change this environment variable, be sure to run an empty `setDTthreads()` call afterwards for the change to take effect; see `?setDTthreads`. The word *throttle* is used to convey that the number of threads is restricted (throttled) for small data tasks. Reducing throttle to 1 will turn off throttling and should revert behaviour to past versions (i.e. using many threads even for small data). Increasing throttle to, say, 65536 will utilize multi-threading only for larger datasets. The value 1024 is a guess. We welcome feedback and test results indicating what the best default should be. - -### BUG FIXES - -1. A NULL timezone on POSIXct was interpreted by `as.IDate` and `as.ITime` as UTC rather than the session's default timezone (`tz=""""`) , [#4085](https://github.com/Rdatatable/data.table/issues/4085). - -2. `DT[i]` could segfault when `i` is a zero-column `data.table`, [#4060](https://github.com/Rdatatable/data.table/issues/4060). Thanks @shrektan for reporting and fixing. - ---- - ---- -title: ""Reference semantics"" -date: ""`{r} Sys.Date()`"" -output: - litedown::html_format -vignette: > - %\VignetteIndexEntry{Reference semantics} - %\VignetteEngine{litedown::vignette} - \usepackage[utf8]{inputenc} ---- - -```{r, echo=FALSE, file='_translation_links.R'} -``` -`{r} .write.translation.links(""Translations of this document are available in: %s"")` - -```{r, echo = FALSE, message = FALSE} -library(data.table) -litedown::reactor(comment = ""# "") -.old.th = setDTthreads(1) -``` - -This vignette discusses *data.table*'s reference semantics which allows to *add/update/delete* columns of a *data.table by reference*, and also combine them with `i` and `by`. It is aimed at those who are already familiar with *data.table* syntax, its general form, how to subset rows in `i`, select and compute on columns, and perform aggregations by group. If you're not familiar with these concepts, please read the [`vignette(""datatable-intro"", package=""data.table"")`](datatable-intro.html) vignette first. - -*** - -## Data {#data} - -We will use the same `flights` data as in the [`vignette(""datatable-intro"", package=""data.table"")`](datatable-intro.html) vignette. - -```{r, echo = FALSE} -options(width = 100L) -``` - -```{r} -flights <- fread(""flights14.csv"") -flights -dim(flights) -``` - -## Introduction - -In this vignette, we will - -1. first discuss reference semantics briefly and look at the two different forms in which the `:=` operator can be used - -2. then see how we can *add/update/delete* columns *by reference* in `j` using the `:=` operator and how to combine with `i` and `by`. - -3. and finally we will look at using `:=` for its *side-effect* and how we can avoid the side effects using `copy()`. - -## 1. Reference semantics - -All the operations we have seen so far in the previous vignette resulted in a new data set. We will see how to *add* new column(s), *update* or *delete* existing column(s) on the original data. - -### a) Background - -Before we look at *reference semantics*, consider the *data.frame* shown below: - -```{r} -DF = data.frame(ID = c(""b"",""b"",""b"",""a"",""a"",""c""), a = 1:6, b = 7:12, c = 13:18) -DF -``` - -When we did: - -```r -DF$c <- 18:13 # (1) -- replace entire column -# or -DF$c[DF$ID == ""b""] <- 15:13 # (2) -- subassign in column 'c' -``` - -both (1) and (2) resulted in deep copy of the entire data.frame in versions of `R < 3.1`. [It copied more than once](https://stackoverflow.com/q/23898969/559784). To improve performance by avoiding these redundant copies, *data.table* utilised the [available but unused `:=` operator in R](https://stackoverflow.com/q/7033106/559784). - -Great performance improvements were made in `R v3.1` as a result of which only a *shallow* copy is made for (1) and not *deep* copy. However, for (2) still, the entire column is *deep* copied even in `R v3.1+`. This means the more columns one subassigns to in the *same query*, the more *deep* copies R does. - -#### *shallow* vs *deep* copy - -A *shallow* copy is just a copy of the vector of column pointers (corresponding to the columns in a *data.frame* or *data.table*). The actual data is not physically copied in memory. - -A *deep* copy on the other hand copies the entire data to another location in memory. - -When subsetting a *data.table* using `i` (e.g., `DT[1:10]`), a *deep* copy is made. However, when `i` is not provided or equals `TRUE`, a *shallow* copy is made. - -# -With *data.table's* `:=` operator, absolutely no copies are made in *both* (1) and (2), irrespective of R version you are using. This is because `:=` operator updates *data.table* columns *in-place* (by reference). - -### b) The `:=` operator - -It can be used in `j` in two ways: - -(a) The `LHS := RHS` form - -```r -DT[, c(""colA"", ""colB"", ...) := list(valA, valB, ...)] - -# when you have only one column to assign to you -# can drop the quotes and list(), for convenience -DT[, colA := valA] -``` - -(b) The functional form - -```r -DT[, `:=`(colA = valA, # valA is assigned to colA - colB = valB, # valB is assigned to colB - ... -)] -``` - ---- - -# Test case created directly using the atime code below (not adapted from any other benchmark), based on the PR, Removes unnecessary data.table call from as.data.table.array https://github.com/Rdatatable/data.table/pull/7010 - ""as.data.table.array improved in #7010"" = atime::atime_test( - setup = { - dims = c(N, 1, 1) - arr = array(seq_len(prod(dims)), dim=dims) - }, - expr = data.table:::as.data.table.array(arr, na.rm=FALSE), - Slow = ""73d79edf8ff8c55163e90631072192301056e336"", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/8397dc3c993b61a07a81c786ca68c22bc589befc) - Fast = ""8397dc3c993b61a07a81c786ca68c22bc589befc""), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7019/commits) that removes inefficiency - - ""isoweek improved in #7144"" = atime::atime_test( - setup = { - set.seed(349) - x = sample(Sys.Date() - 0:5000, N, replace=TRUE) - }, - expr = data.table::isoweek(x), - Slow = ""548410d23dd74b625e8ea9aeb1a5d2e9dddd2927"", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/548410d23dd74b625e8ea9aeb1a5d2e9dddd2927) - Fast = ""c0b32a60466bed0e63420ec105bc75c34590865e""), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7144/commits) that uses a much faster implementation - - # Regression introduced in #7404 (grouped by factor). - ""DT[by] max regression fixed in #7480"" = atime::atime_test( - N = as.integer(10^seq(3, 5, by=0.5)), - setup = { - dt = data.table( - id = as.factor(rep(seq_len(N), each = 100L)), - V1 = 1L - ) - }, - expr = data.table:::`[.data.table`(dt, , base::max(V1, na.rm = TRUE), by = id), - Before = ""476de7e3"", - Regression = ""6f49bf1"", - Fixed = ""b6ad1a4"", - seconds.limit = 1), - tests=extra.test.list) -# nolint end: undesirable_operator_linter. - ---- - -require(methods) -if (exists(""test.data.table"", .GlobalEnv, inherits=FALSE)) { - if ((tt<-compiler::enableJIT(-1))>0) - cat(""This is dev mode and JIT is enabled (level "", tt, "") so there will be a brief pause around the first test.\n"", sep="""") -} else { - require(data.table) - test = data.table:::test - null.data.table = data.table:::null.data.table - INT = data.table:::INT -} - -sugg = c(""bit64"") -for (s in sugg) { - assign(paste0(""test_"",s), loaded<-suppressWarnings(suppressMessages( - library(s, character.only=TRUE, logical.return=TRUE, quietly=TRUE, warn.conflicts=FALSE, pos=""package:base"") # attach at the end for #5101 - ))) - if (!loaded) cat(""\n**** Suggested package"",s,""is not installed or has dependencies missing. Tests using it will be skipped.\n\n"") -} - -# := by group -DT = data.table(a=1:3,b=(1:9)/10) -test(611.1,optimize=c(0L, 2L), DT[,v:=sum(b),by=a], data.table(a=1:3,b=(1:9)/10,v=c(1.2,1.5,1.8))) -setkey(DT,a) -test(611.2,optimize=c(0L, 2L), DT[,v:=min(b),by=a], data.table(a=1:3,b=(1:9)/10,v=(1:3)/10,key=""a"")) -# Combining := by group with i -test(611.3,optimize=c(0L, 2L), DT[a>1,p:=sum(b)]$p, rep(c(NA,3.3),c(3,6))) -test(611.4,optimize=c(0L, 2L), DT[a>1,q:=sum(b),by=a]$q, rep(c(NA,1.5,1.8),each=3)) -# 612 was just level repetition of 611 -# Assign to subset ok (NA initialized in the other items) ok : -test(613,optimize=c(0L, 2L), DT[J(2),w:=8.3]$w, rep(c(NA,8.3,NA),each=3)) -test(614,optimize=c(0L, 2L), DT[J(3),x:=9L]$x, rep(c(NA_integer_,NA_integer_,9L),each=3)) -test(615,optimize=c(0L, 2L), DT[J(2),z:=list(list(c(10L,11L)))]$z, rep(list(NULL, 10:11, NULL),each=3)) -# 616, 617 removed in #5245 - -# Empty i clause, #2034. Thanks to Chris for testing, tests from him. Plus changes from #759 -ans = copy(DT)[,r:=NA_real_] -test(618.1,optimize=c(0L, 2L), copy(DT)[a>3,r:=sum(b)], ans) -test(618.2,optimize=c(0L, 2L), copy(DT)[J(-1),r:=sum(b)], ans) -test(618.3,optimize=c(0L, 2L), copy(DT)[NA,r:=sum(b)], ans) -test(618.4,optimize=c(0L, 2L), copy(DT)[0,r:=sum(b)], ans) -test(618.5,optimize=c(0L, 2L), copy(DT)[NULL,r:=sum(b)], null.data.table()) -# test 619 was level 2 of 618 -# test 620 was removed in #5245 - -DT = data.table(x=letters, key=""x"") -test(621,optimize=c(0L, 2L), copy(DT)[J(""bb""), x:=""foo""], DT) # when no update, key should be retained -test(622,optimize=c(0L, 2L), copy(DT)[J(""bb""), x:=""foo"",nomatch=0], DT, warning=""ignoring nomatch"") - -set.seed(2) -DT = data.table(a=rnorm(5)*10, b=1:5) -test(623,optimize=c(0L, 2L), copy(DT)[,s:=sum(b),by=round(a)%%2]$s, c(10L,5L,5L,10L,10L)) -# test 623 subsumes 623.1 and 623.2 for testing both levels - -# Setup for test 656.x - gforce tests -set.seed(9) -n = 1e3 -DT = data.table(grp1=sample.int(150L, n, replace=TRUE), - grp2=sample.int(150L, n, replace=TRUE), - x=rnorm(n), - y=rnorm(n)) -opt = 0:2 -out = c('GForce FALSE', 'GForce FALSE' ,'GForce TRUE') -test(656.1,optimize=opt, DT[ , mean(x), by=grp1, verbose=TRUE], output=out) -test(656.2,optimize=opt, DT[ , list(mean(x)), by=grp1, verbose=TRUE], output=out) -test(656.3,optimize=opt, DT[ , list(mean(x), mean(y)), by=grp1, verbose=TRUE], output=out) -# 657-658 were for levels 1,2, resp. - ---- - -### Testing - -`data.table` uses a series of unit tests to exhibit code that is expected to work. These are primarily stored in [`inst/tests/tests.Rraw`](https://github.com/Rdatatable/data.table/blob/master/inst/tests/tests.Rraw). They come primarily from two places -- when new features are implemented, the author constructs minimal examples demonstrating the expected common usage of said feature, including expected failures/invalid use cases (e.g., the [initial assay of `fwrite` included 24 tests](https://github.com/Rdatatable/data.table/pull/1613/files#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae)). Second, when kind users such as yourself happen upon some aberrant behavior in their everyday use of `data.table` (typically, some edge case that slipped through the cracks in the coding logic of the original author). We try to be thorough -- for example there were initially [141 tests of `split.data.table`](https://github.com/Rdatatable/data.table/commit/5f7a435fea5622bfbe1d5f1ffa99fa94a6a054ae#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae), and that number has since grown! - -When you file a pull request, you should add some tests to this file with this in mind -- for new features, try to cover possible use cases extensively (we use [Codecov](https://app.codecov.io/gh/Rdatatable/data.table) to make it a bit easier to see how well you've done to minimally cover any new code you've added); for bug fixes, include a minimal version of the problem you've identified and write a test to ensure that your fix indeed works, and thereby guarantee that your fix continues to work as the codebase is further modified in the future. We encourage you to scroll around in `tests.Rraw` a bit to get a feel for the types of examples that are being created, and how bugs are tested/features evaluated. - -What numbers should be used for new tests? Numbers should be new relative to current master at the time of your PR. If another PR is merged before yours, then there may be a conflict, but that is no problem, as [a Committer will fix the test numbers when merging your PR](https://github.com/Rdatatable/data.table/pull/4731#issuecomment-768858134). - -#### Using `test` - -See [`?test`](https://rdatatable.gitlab.io/data.table/reference/test.html). - -**References:** If you are not sure how to create a PR, but would like to contribute, these links should help get you started: - -1. **[How to Github: Fork, Branch, Track, Squash and Pull request](https://gun.io/blog/how-to-github-fork-branch-and-pull-request/)**. -1. **[Squashing Github pull requests into a single commit](http://eli.thegreenplace.net/2014/02/19/squashing-github-pull-requests-into-a-single-commit)**. -1. **[Github help](https://help.github.com/articles/using-pull-requests/)** - you'll need the *fork and pull* model. - -#### Performance testing - -If your PR may have an effect on time/memory usage, please consider adding a performance test, either in the same PR, or a follow-up PR. Note that first-time contributors _must_ do so in a follow-up PR, since the tests are only run on PRs from branches created directly in the Rdatatable/data.table repo. See the [Performance testing](https://github.com/Rdatatable/data.table/wiki/Performance-testing) wiki page for details. - -Minimal first time PR ---------------------- - -```shell -cd /tmp # or anywhere safe to play -git config --global core.autocrlf false # Windows-only preserve \n in test data -git clone https://github.com/Rdatatable/data.table.git -cd data.table -R CMD build . -R CMD check data.table_*.tar.gz -# ... -# Status: OK -``` - -Congratulations - you've just compiled and tested the very latest version of data.table in development. Everything looks good. Now make your changes. Using an editor of your choice, edit the appropriate `.R`, `.md`, `NEWS` and `tests.Rraw` files. Test your changes: - -```shell -rm data.table_*.tar.gz # clean-up old build(s) -R CMD build . -R CMD check data.table_*.tar.gz -``` - ---- - -# Moved here out from data.table.R on 10 Aug 2017. See data.table.R for history prior to that. - ---- - -# if a change in the number of columns is suspected - if (ok==0L) # ok==0 so no warning when loaded from disk (-1) [-1 considered TRUE by R] - if (is.data.table(x)) warningf(""A shallow copy of this data.table was taken so that := can add or remove %d columns by reference. At an earlier point, this data.table was copied by R (or was created manually using structure() or similar). Avoid names<- and attr<- which in R currently (and oddly) may copy the whole data.table. Use set* syntax instead to avoid copying: ?set, ?setnames and ?setattr. It's also not unusual for data.table-agnostic packages to produce tables affected by this issue. If this message doesn't help, please report your use case to the data.table issue tracker so the root cause can be fixed or this message improved."", length(newnames)) - } - # ok <- selfrefok above called without verbose -- only activated when - # ok=-1 which will trigger setalloccol with verbose in the next - # branch, which again calls _selfrefok and returns the message then - # !is.data.table for DF |> DT(,:=) tests 2212.16-19 (#5113) where a shallow copy is routine for data.frame - if ( - ( - !is.null(newnames) || # adding new columns - is.null(jsub) || (jsub %iscall% ""list"" && any(vapply_1b(jsub[-1], is.null))) # removing columns - ) && ( - (ok<1L) || # unsafe to resize - (truelength(x) < ncol(x)+length(newnames)) # not enough space for new columns - ) - ) { - DT = x # in case getOption contains ""ncol(DT)"" as it used to. TODO: warn and then remove - n = length(newnames) + eval(getOption(""datatable.alloccol"")) # TODO: warn about expressions and then drop the eval() - # i.e. reallocate at the size as if the new columns were added followed by setalloccol(). - name = substitute(x) - if (is.name(name) && ok && verbose) { # && NAMED(x)>0 (TO DO) # ok here includes -1 (loaded from disk) - catf(""Growing vector of column pointers from truelength %d to %d. A shallow copy has been taken, see ?setalloccol. Only a potential issue if two variables point to the same data (we can't yet detect that well) and if not you can safely ignore this. To avoid this message you could setalloccol() first, deep copy first using copy(), wrap with suppressWarnings() or increase the 'datatable.alloccol' option.\n"", truelength(x), n) - # #1729 -- copying to the wrong environment here can cause some confusion - if (ok == -1L) catf(""Note that the shallow copy will assign to the environment from which := was called. That means for example that if := was called within a function, the original table may be unaffected.\n"") - ---- - -7. Efficient conversion of `xts` to data.table. Closes [#882](https://github.com/Rdatatable/data.table/issues/882). Check examples in `?as.xts.data.table` and `?as.data.table.xts`. Thanks to @jangorecki for the PR. - - 8. `rbindlist` gains `idcol` argument which can be used to generate an index column. If `idcol=TRUE`, the column is automatically named `.id`. Instead you can also provide a column name directly. If the input list has no names, indices are automatically generated. Closes [#591](https://github.com/Rdatatable/data.table/issues/591). Also thanks to @KevinUshey for filing [#356](https://github.com/Rdatatable/data.table/issues/356). - - 9. A new helper function `uniqueN` is now implemented. It is equivalent to `length(unique(x))` but much faster. It handles `atomic vectors`, `lists`, `data.frames` and `data.tables` as input and returns the number of unique rows. Closes [#884](https://github.com/Rdatatable/data.table/issues/884). Gains by argument. Closes [#1080](https://github.com/Rdatatable/data.table/issues/1080). Closes [#1224](https://github.com/Rdatatable/data.table/issues/1224). Thanks to @DavidArenburg, @kevinmistry and @jangorecki. - - 10. Implemented `transpose()` to transpose a list and `tstrsplit` which is a wrapper for `transpose(strsplit(...))`. This is particularly useful in scenarios where a column has to be split and the resulting list has to be assigned to multiple columns. See `?transpose` and `?tstrsplit`, [#1025](https://github.com/Rdatatable/data.table/issues/1025) and [#1026](https://github.com/Rdatatable/data.table/issues/1026) for usage scenarios. Closes both #1025 and #1026 issues. - * Implemented `type.convert` as suggested by Richard Scriven. Closes [#1094](https://github.com/Rdatatable/data.table/issues/1094). - - 11. `melt.data.table` - * can now melt into multiple columns by providing a list of columns to `measure.vars` argument. Closes [#828](https://github.com/Rdatatable/data.table/issues/828). Thanks to Ananda Mahto for the extended email discussions and ideas on generating the `variable` column. - * also retains attributes wherever possible. Closes [#702](https://github.com/Rdatatable/data.table/issues/702) and [#993](https://github.com/Rdatatable/data.table/issues/993). Thanks to @richierocks for the report. - * Added `patterns.Rd`. Closes [#1294](https://github.com/Rdatatable/data.table/issues/1294). Thanks to @MichaelChirico. - - 12. `.SDcols` - * understands `!` now, i.e., `DT[, .SD, .SDcols=!""a""]` now works, and is equivalent to `DT[, .SD, .SDcols = -c(""a"")]`. Closes [#1066](https://github.com/Rdatatable/data.table/issues/1066). - * accepts logical vectors as well. If length is smaller than number of columns, the vector is recycled. Closes [#1060](https://github.com/Rdatatable/data.table/issues/1060). Thanks to @StefanFritsch. - - 13. `dcast` can now: - * cast multiple `value.var` columns simultaneously. Closes [#739](https://github.com/Rdatatable/data.table/issues/739). - * accept multiple functions under `fun.aggregate`. Closes [#716](https://github.com/Rdatatable/data.table/issues/716). - * supports optional column prefixes as mentioned under [this SO post](https://stackoverflow.com/q/26225206/559784). Closes [#862](https://github.com/Rdatatable/data.table/issues/862). Thanks to @JohnAndrews. - * works with undefined variables directly in formula. Closes [#1037](https://github.com/Rdatatable/data.table/issues/1037). Thanks to @DavidArenburg for the MRE. - * Naming conventions on multiple columns changed according to [#1153](https://github.com/Rdatatable/data.table/issues/1153). Thanks to @MichaelChirico for the FR. - * also has a `sep` argument with default `_` for backwards compatibility. [#1210](https://github.com/Rdatatable/data.table/issues/1210). Thanks to @dbetebenner for the FR. - ---- - -# .SD reference in '...' passed to lapply(FUN=) is recognized as data.table -test(2331, lapply(list(data.table(a=1:2)), `[`, j=.SD[1L]), list(data.table(a=1L))) - -# 5885 implement frev -d = c(NA, NaN, Inf, -Inf) -test(2332.00, frev(c(FALSE, NA)), rev(c(FALSE, NA))) -test(2332.01, frev(c(0L, NA)), rev(c(0L, NA))) -test(2332.02, frev(d), rev(d)) -test(2332.03, frev(c(NA, 1, 0+2i)), rev(c(NA, 1, 0+2i))) -test(2332.04, frev(as.raw(0:1)), rev(as.raw(0:1))) -test(2332.05, frev(NULL), rev(NULL)) -test(2332.06, frev(character(5)), rev(character(5))) -test(2332.07, frev(integer(0)), rev(integer(0))) -test(2332.08, frev(list(1, ""a"")), rev(list(1, ""a""))) -test(2332.09, {x=c(0L, NA); setfrev(x); x}, c(NA, 0L)) -test(2332.10, {x=d; setfrev(x); x}, c(-Inf, Inf, NaN, NA)) -test(2332.11, {x=c(NA, 1, 0+2i); setfrev(x); x}, c(0+2i, 1, NA)) -test(2332.12, {x=as.raw(0:1); setfrev(x); x}, as.raw(1:0)) -test(2332.13, {x=NULL; setfrev(x); x}, NULL) -test(2332.14, {x=character(5); setfrev(x); x}, character(5)) -test(2332.15, {x=integer(0); setfrev(x); x}, integer(0)) -test(2332.16, {x=list(1, ""a""); setfrev(x); x}, list(""a"", 1)) -test(2332.17, frev(1:1e2), rev(1:1e2)) -# copy arguments -x = 1:3 -test(2332.21, {frev(x); x}, 1:3) -test(2332.22, {setfrev(x); x}, 3:1) -test(2332.23, address(x) == address(setfrev(x))) -test(2332.24, address(x) != address(frev(x))) -# do not alter on subsets -test(2332.25, {setfrev(x[1:2]); x}, 1:3) -# levels -f = as.factor(letters) -test(2332.31, frev(f), rev(f)) -test(2332.32, frev(as.IDate(1:10)), as.IDate(10:1)) -test(2332.33, frev(as.IDate(1:10)), as.IDate(10:1)) -# names -x = c(a=1L, b=2L, c=3L) -test(2332.41, frev(x), rev(x)) -test(2332.42, setfrev(x), x) -x = c(a=1L, b=2L, c=3L) -test(2332.43, {frev(x); names(x)}, c(""a"",""b"",""c"")) -# attributes -x = structure(1:10, class = c(""IDate"", ""Date""), att = 1L) -test(2332.51, attr(frev(x), ""att""), attr(rev(x), ""att"")) -test(2332.52, class(frev(x)), class(rev(x))) -test(2332.53, attr(setfrev(x), ""att""), 1L) -test(2332.54, class(setfrev(x)), c(""IDate"", ""Date"")) -x = structure(integer(0), att = 1L) -test(2332.55, attr(frev(x), ""att""), attr(rev(x), ""att"")) -# errors -test(2332.61, frev(data.table()), error=""should not be data.frame or data.table"") -test(2332.62, frev(expression(1)), error=""is not supported by frev"") -if (test_bit64) { - x = as.integer64(c(1, NA, 3)) - test(2332.71, frev(x), rev(x)) - test(2332.72, setfrev(x), x) -} -# support rotate idiom -M1 = M2 = matrix(1:4, nrow=2) -test(2332.81, {M1[]=frev(M1); M1}, {M2[]=rev(M2); M2}) - -# regression test of edge case report #4964 -test(2333, as.expression(data.table(a = 1))[[""a""]], 1) - -# regression test for hexdigits subscript overrun (uint8_t wraps over 255, unsigned overflow is well defined in c) -local({ - f = tempfile() - on.exit(unlink(f)) - # the line is likely invalid in current encoding, so disable any translation, #7209 - # test.data.table() sets options(encoding=""UTF-8""), so go the long way around. - ff = file(f, encoding = """") - tryCatch( - writeLines(c('a', rep('0x1.ffffp0', 10000L), `Encoding<-`('0x1.ff\x9fp0', 'bytes'), rep('0x1.ffffp0', 20000L)), ff), - finally = close(ff) - ) - test(2334, names(fread(f)), ""a"") -}) - -# Tests for new isoyear() helper (complement to isoweek) #7154 -test(2335.1, isoyear(as.IDate(""2019-12-30"")), 2020L) # End of year edge case -test(2335.2, isoyear(as.IDate(""2016-01-01"")), 2015L) # Start of year edge case -test(2335.3, isoyear(as.IDate(""2023-08-15"")), 2023L) # Normal mid-year case -test(2335.4, isoyear(as.IDate(c(""2019-12-30"", ""2016-01-01"", ""2023-08-15""))),c(2020L, 2015L, 2023L)) -test(2335.5, isoyear(""2019-12-30""), 2020L) -test(2335.6, isoyear(as.Date(""2019-12-30"")), 2020L) - ---- - -#: data.table.R:816 -#, c-format -msgid ""by=c(...), key(...) or names(...) must evaluate to 'character'"" -msgstr """" -""результатом вычисления by=c(...), key(...) или names(...) должен быть вектор "" -""строк"" - -#: data.table.R:826 -#, c-format -msgid """" -""'by' is a character vector length %d but one or more items include a comma. "" -""Either pass a vector of column names (which can contain spaces, but no "" -""commas), or pass a vector length 1 containing comma separated column names. "" -""See ?data.table for other possibilities."" -msgstr """" -""'by' - это вектор из %d сток, но один или несколько элементов содержат "" -""запятую. Либо передайте вектор имен столбцов (который может содержать "" -""пробелы, но не запятые), либо передайте одну строку, содержащую имена "" -""столбцов, разделенные запятыми. Другие возможности см. в ?data.table."" - -#: data.table.R:833 -#, c-format -msgid ""At least one entry of by is empty"" -msgstr ""Как минимум один элемент «by» пуст"" - -#: data.table.R:860 -msgid ""by index '%s' but that index has 0 length. Ignoring."" -msgstr ""«by» использовано с индексом '%s', но он нулевой длины. Пропускаю его."" - -#: data.table.R:883 -msgid ""i clause present and columns used in by detected, only these subset: %s"" -msgstr ""аргумент «i» использует следующие столбцы из «by»: %s"" - -#: data.table.R:886 -msgid """" -""i clause present but columns used in by not detected. Having to subset all "" -""columns before evaluating 'by': '%s'"" -msgstr """" -""аргумент «i» не использует столбцы из «by». Вычисляю подмножество всех "" -""столбцов, прежде чем вычислить «by»: '%s'"" - -#: data.table.R:908 -#, c-format -msgid """" -""'by' appears to evaluate to column names but isn't c() or key(). Use "" -""by=list(...) if you can. Otherwise, by=eval%s should work. This is for "" -""efficiency so data.table can detect which columns are needed."" -msgstr """" -""По-видимому, результатом вычисления «by» являются имена столбцов, но "" -""переданное выражение не является c() или key(). Пожалуйста, используйте "" -""by=list(...), если возможно. В противном случае подойдет by=eval%s. Это "" -""сделано для эффективности, чтобы data.table могла определить, какие столбцы "" -""нужны."" - -#: data.table.R:919 -#, c-format -msgid """" -""'by' or 'keyby' must evaluate to a vector or a list of vectors (where 'list' "" -""includes data.table and data.frame which are lists, too)"" -msgstr """" -""Результатом вычисления «by» или «keyby» должен быть вектор или список "" -""векторов (что включает data.table и data.frame)"" - -#: data.table.R:923 -#, c-format -msgid """" -""Column or expression %d of 'by' or 'keyby' is type '%s' which is not "" -""currently supported. If you have a compelling use case, please add it to "" -""https://github.com/Rdatatable/data.table/issues/1597. As a workaround, "" -""consider converting the column to a supported type, e.g. by=sapply(list_col, "" -""toString), whilst taking care to maintain distinctness in the process."" -msgstr """" -""Столбец или выражение №%d из «by» или «keyby» имеет тип '%s', который в "" -""настоящее время не поддерживается. Если у вас есть убедительный пример "" -""использования, пожалуйста, добавьте его на https://github.com/Rdatatable/"" -""data.table/issues/1597. Можно также попробовать преобразовать столбец к "" -""поддерживаемому типу, например by=sapply(list_col, toString), позаботившись "" -""при этом о сохранении различимости."" - -#: data.table.R:951 -msgid """" -""by-expression '%s' is not named, and the auto-generated name '%s' clashed "" -""with variable(s) in j. Therefore assigning the entire by-expression as name."" -msgstr """" -""'by'-выражение '%s' не имеет имени, и автоматически придуманное имя '%s' "" -""пересекается со столбцами «j», так что использую выражение целиком в "" -""качестве его имени."" - -#: data.table.R:985 -#, c-format -msgid ""Item %d of the .() or list() passed to j is missing"" -msgstr ""Пропущенный элемент №%d из .() или list(), переданного как «j»"" - ---- - -```{r, test_id, message=FALSE, results=""show"", echo=TRUE, warning=FALSE} -require(data.table) # print? -DT = data.table(x=1:3, y=4:6) # no -DT # yes -DT[, z := 7:9] # no -print(DT[, z := 10:12]) # yes -if (1 < 2) DT[, a := 1L] # no -DT # yes -``` -Some text. - ---- - -Para que data.table pueda heredar de `data.frame` sin usar `...`. Si usáramos `...`, no se detectarían los nombres de argumentos no válidos. - -El argumento `drop` nunca se utiliza en `[.data.table`. Es un marcador de posición para paquetes que no son compatibles con data.table cuando usan la sintaxis `[.data.frame` directamente en un data.table. - -## ¡Las uniones continuas son geniales y rapidísimas! ¿Fue difícil programarlas? - -La fila que prevalece en o antes de la fila `i` es la última fila que la búsqueda binaria prueba. Por lo tanto, `roll = TRUE` es básicamente un cambio en el código C de búsqueda binaria para devolver esa fila. - -## ¿Por qué `DT[i, col := value]` devuelve `DT` completo? Esperaba que no hubiera ningún valor visible (consistente con `<-`), o un mensaje o valor de retorno que indicara cuántas filas se actualizaron. No es evidente que los datos se hayan actualizado por referencia. - -Esto ha cambiado en la v1.8.3 para cumplir con sus expectativas. Actualice. - -Se devuelve la totalidad de `DT` (ahora de forma invisible) para que la sintaxis compuesta funcione; p. ej., `DT[i, done := TRUE][ , sum(done)]`. El número de filas actualizadas se devuelve cuando `verbose` es `TRUE`, ya sea por consulta o globalmente mediante `options(datatable.verbose = TRUE)`. - -## Bien, gracias. ¿Qué tenía de difícil que el resultado de `DT[i, col := valor]` se devolviera de forma invisible? - -R activa internamente la visibilidad para `[`. El valor de la columna eval de FunTab (ver [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) para `[` es `0`, lo que significa que se activa `R_Visible` (ver [R-Internals sección 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting)). Por lo tanto, al intentar `invisible()` o configurar `R_Visible` a `0` directamente, `eval` en [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) lo activaba de nuevo. - -Para solucionar este problema, la clave fue dejar de intentar detener la ejecución del método de impresión después de un `:=`. En su lugar, dentro de `:=` ahora (a partir de la v1.8.3) configuramos un indicador global que el método de impresión usa para determinar si imprimir o no. - -## ¿Por qué a veces tengo que escribir 'DT' dos veces después de usar ':=' para imprimir el resultado en la consola? - -Esta es una desventaja desafortunada para que [#869](https://github.com/Rdatatable/data.table/issues/869) funcione. Si se usa un `:=` dentro de una función sin `DT[]` antes del final de la función, la próxima vez que se escriba `DT` en el prompt, no se imprimirá nada. Un `DT` repetido se imprimirá. Para evitar esto: incluya un `DT[]` después del último `:=` en su función. Si eso no es posible (por ejemplo, no es una función que pueda cambiar), se garantiza que `print(DT)` y `DT[]` en el prompt se imprimirán. Como antes, agregar un `[]` adicional al final de la consulta `:=` es un modismo recomendado para actualizar y luego imprimir; por ejemplo, `DT[,foo:=3L][]`. - -## He observado que `base::cbind.data.frame` (y `base::rbind.data.frame`) parecen ser modificados por data.table. ¿Cómo es posible? ¿Por qué? - ---- - -## Why `data.table`? - -* concise syntax: fast to type, fast to read -* fast speed -* memory efficient -* careful API lifecycle management -* community -* feature rich - -## Features - -* fast and friendly delimited **file reader**: **[`?fread`](https://rdatatable.gitlab.io/data.table/reference/fread.html)**, see also [convenience features for _small_ data](https://github.com/Rdatatable/data.table/wiki/Convenience-features-of-fread) -* fast and feature rich delimited **file writer**: **[`?fwrite`](https://rdatatable.gitlab.io/data.table/reference/fwrite.html)** -* low-level **parallelism**: many common operations are internally parallelized to use multiple CPU threads -* fast and scalable aggregations; e.g. 100GB in RAM (see [benchmarks](https://duckdblabs.github.io/db-benchmark/) on up to **two billion rows**) -* fast and feature rich joins: **ordered joins** (e.g. rolling forwards, backwards, nearest and limited staleness), **[overlapping range joins](https://github.com/Rdatatable/data.table/wiki/talks/EARL2014_OverlapRangeJoin_Arun.pdf)** (similar to `IRanges::findOverlaps`), **[non-equi joins](https://github.com/Rdatatable/data.table/wiki/talks/ArunSrinivasanUseR2016.pdf)** (i.e. joins using operators `>, >=, <, <=`), **aggregate on join** (`by=.EACHI`), **update on join** -* fast add/update/delete columns **by reference** by group using no copies at all -* fast and feature rich **reshaping** data: **[`?dcast`](https://rdatatable.gitlab.io/data.table/reference/dcast.data.table.html)** (_pivot/wider/spread_) and **[`?melt`](https://rdatatable.gitlab.io/data.table/reference/melt.data.table.html)** (_unpivot/longer/gather_) -* **any R function from any R package** can be used in queries not just the subset of functions made available by a database backend, also columns of type `list` are supported -* has **[no dependencies](https://en.wikipedia.org/wiki/Dependency_hell)** at all other than base R itself, for simpler production/maintenance -* the R dependency is **as old as possible for as long as possible**, currently R 3.5.0 (2018), and we continuously test against that version - -## Installation - -```r -install.packages(""data.table"") - -# latest development version (only if newer available) -data.table::update_dev_pkg() - -# latest development version (force install) -install.packages(""data.table"", repos=""https://rdatatable.gitlab.io/data.table"") -``` - -See [the Installation wiki](https://github.com/Rdatatable/data.table/wiki/Installation) for more details. - -## Usage - -Use `data.table` subset `[` operator the same way you would use `data.frame` one, but... - -* no need to prefix each column with `DT$` (like `subset()` and `with()` but built-in) -* any R expression using any package is allowed in `j` argument, not just list of columns -* extra argument `by` to compute `j` expression by group - -```r -library(data.table) -DT = as.data.table(iris) - -# FROM[WHERE, SELECT, GROUP BY] -# DT [i, j, by] - -DT[Petal.Width > 1.0, mean(Petal.Length), by = Species] -# Species V1 -#1: versicolor 4.362791 -#2: virginica 5.552000 -``` - -### Getting started - -* [Introduction to data.table](https://cran.r-project.org/package=data.table/vignettes/datatable-intro.html) vignette -* [Getting started](https://github.com/Rdatatable/data.table/wiki/Getting-started) wiki page -* [Examples](https://rdatatable.gitlab.io/data.table/reference/data.table.html#examples) produced by `example(data.table)` - -### Cheatsheets - - - -## Community - ---- - -# in order as they're attached in a normal R session, to match that if these actually have an effect, e.g. under R_DEFAULT_PACKAGES=NULL -# NB: pos= is required for these symbols to resolve searching 'upward' from data.table -- if these packages are not already attached, -# and we don't use pos=, they'll wind up 'below' data.table on the search() path --> their symbols won't resolve since, when running -# from the installed package, this is evaluated from data.table's namespace. -if (""include.only"" %in% names(formals(library))) { # TODO(R>=3.6.0): Remove this. - libraryRobust = library -} else { - libraryRobust = function(..., include.only) library(...) -} -libraryRobust(stats, include.only=c(""lm"", ""median"", ""na.omit"", ""rnorm"", ""runif"", ""sd"", ""setNames"", ""var"", ""weighted.mean""), pos=""package:base"") -libraryRobust(utils, include.only=c(""capture.output"", ""combn"", ""head"", ""read.csv"", ""read.delim"", ""read.table"", ""tail"", ""type.convert"", ""write.csv"", ""write.table""), pos=""package:base"") -libraryRobust(datasets, include.only=c(""airquality"", ""BOD"", ""cars"", ""ChickWeight"", ""CO2"", ""iris"", ""mtcars""), pos=""package:base"") - -if (exists(""test.data.table"", .GlobalEnv, inherits=FALSE)) { - if ((tt<-compiler::enableJIT(-1))>0) - cat(""This is dev mode and JIT is enabled (level "", tt, "") so there will be a brief pause around the first test.\n"", sep="""") - rm_all = function() {} - DTfun = DT ## otherwise DT would be re-defined by many tests -} else { - require(data.table) - # Make symbols to the installed version's ::: so that we can i) test internal-only not-exposed R functions - # in the test suite when user runs test.data.table() from installed package AND ii) so that in dev the same - # tests can be used but in dev they test the package in .GlobalEnv. If we used ::: throughout tests, that - # would pick up the installed version and in dev you'd have to reinstall every time which slows down dev. - # NB: The string ""data.table::"" (which covers ""data.table:::"" too) should exist nowhere else in this file - # other than here inside this branch. - ---- - -## I have a question. I know the r-help posting guide tells me to contact the maintainer (not r-help), but is there a larger group of people I can ask? -Please see the [support guide](https://github.com/Rdatatable/data.table/wiki/Support) on the project's homepage which contains up-to-date links. - -## Where are the datatable-help archives? -The [homepage](https://github.com/Rdatatable/data.table/wiki) contains links to the archives in several formats. - -## I'd prefer not to post on the Issues page, can I mail just one or two people privately? -Sure. You're more likely to get a faster answer from the Issues page or Stack Overflow, though. Further, asking publicly in those places helps build the general knowledge base. - -## I have created a package that uses data.table. How do I ensure my package is data.table-aware so that inheritance from `data.frame` works? - -Please see [this answer](https://stackoverflow.com/a/10529888/403310). - -```{r, echo=FALSE} -setDTthreads(.old.th) -``` - ---- - -40. Following latest recommended testthat practices and to avoid a warning that it now issues, `inst/tests/testthat` has been moved to `/tests/testthat`. This means that testthat tests won't be installed for use by users by default and that `test_package(""data.table"")` will now fail with error `No matching test file in dir` and also a warning `Placing tests in inst/tests/ is deprecated. Please use tests/testthat/ instead`. (That warning seems to be misleading since we already have made that move.) To install testthat tests (and this applies to all packages using testthat not just data.table) you need to follow the [deleted instructions](https://github.com/hadley/testthat/commit/0a7d27bb9ea545be7da1a10e511962928d888302) in testthat's README; i.e., reinstall data.table either with `--install-tests` passed to `R CMD INSTALL` or `INSTALL_opts = ""--install-tests""` passed to `install.packages()`. After that, `test_package(""data.table"")` will work. However, the main test suite of data.table (5,000+ tests) doesn't use testthat at all. Those tests are always installed so that `test.data.table()` can always be run by users at any time to confirm your installation on your platform is working correctly. Sometimes when supporting you, you may be asked to run `test.data.table()` and provide the output. Particularly now that data.table uses OpenMP. The file `/tests/tests.R` (which just calls `test.data.table()`) has been renamed to `/tests/main.R` to make this clearer to those looking at the GitHub repository and a comment has been added to `/tests/main.R` pointing to `/inst/tests/tests.Rraw` where those tests live. Some of these tests test data.table's compatibility with other packages and that is the reason those packages are listed in `DESCRIPTION:Suggests`. If you don't have some of those packages installed, `test.data.table()` will print output that it has skipped tests of compatibility with those packages. On CRAN all Suggests packages are available and data.table's tests of compatibility with them are tested by CRAN every day. - - 41. The license field is changed from ""GPL (>= 2)"" to ""GPL-3 | file LICENSE"" due to independent communication from two users of data.table at Google. The lack of an explicit license file was preventing them from contributing patches to data.table. Further, Google lawyers require the full text of the license and not a URL to the license. Since this requirement appears to require the choice of one license, we opted for GPL-3 and we checked the GPL-3 is fine by Google for them to use and contribute to. Accordingly, data.table's LICENSE file is an exact duplicate copy of the canonical GPL-3. - - 42. Thanks to @rrichmond for finding and reporting a regression in dev before release with `roll` not respecting fractions in type double, [#1904](https://github.com/Rdatatable/data.table/issues/1904). For example dates like `zoo::as.yearmon(""2016-11"")` which is stored as `double` value 2016.833. Fixed and test added. - - -## data.table v1.9.6 (on CRAN 19 Sep 2015) - -### NEW FEATURES - ---- - -* Prettier printing of list columns. The first 6 items of atomic vectors - are collapsed with "","" followed by a trailing "","" if there are more than - 6, FR#1608. This difference to data.frame has been added to FAQ 2.17. - Embedded objects (such as a data.table) print their class name only to avoid - seemingly mangled output, bug #1803. Thanks to Yike Lu for reporting. - For example: - > data.table(x=letters[1:3], - y=list( 1:10, letters[1:4], data.table(a=1:3,b=4:6) )) - x y - 1: a 1,2,3,4,5,6, - 2: b a,b,c,d - 3: c - - * Warnings added when joining character to factor, and factor to character. - Character to character is now preferred in joins and needs no coercion. - Even so, these coercions have been made much more efficient by taking - a shallow copy of i internally, avoiding a full deep copy of i. - - * Ordered subsets now retain x's key. Always for logical and keyed i, using - base::is.unsorted() for integer and unkeyed i. Implements FR#295. - - * mean() is now automatically optimized, #1231. This can speed up grouping - by 20 times when there are a large number of groups. See wiki point 3, which - is no longer needed to know. Turn off optimization by setting - options(datatable.optimize=0). - - * DT[,lapply(.SD,...),by=...] is now automatically optimized, #2067. This can speed - up applying a function by column by group, by over 20 times. See wiki point 5 - which is no longer needed to know. In other words: - DT[,lapply(.SD,sum),by=grp] - is now just as fast as : - DT[,list(x=sum(x),y=sum(y)),by=grp] - Don't forget to use .SDcols when a subset of columns is needed. - - * The package is now Byte Compiled (when installed in R 2.14.0 or later). Several - internal speed improvements were made in this version too, such as avoiding - internal copies. If you find 1.8.2 is faster, before attributing that to Byte - Compilation, please install the package without Byte Compilation and compare - ceteris paribus. If you find cases where speed has slowed, please let us know. - - * sapply(DT,class) gets a significant speed boost by avoiding a call to unclass() - in as.list.data.table() called by lapply(DT,...), which copied the entire object. - Thanks to a question by user1393348 on Stack Overflow, implementing #2000. - https://stackoverflow.com/questions/10584993/r-loop-over-columns-in-data-table - - * The J() alias is now deprecated outside DT[...], but will still work inside - DT[...], as in DT[J(...)]. - J() is conflicting with function J() in package XLConnect (#1747) - and rJava (#2045). For data.table to change is easier, with some efficiency - advantages too. The next version of data.table will issue a warning from J() - when used outside DT[...]. The version after will remove it. Only then will - the conflict with rJava and XLConnect be resolved. - Please use data.table() directly instead of J(), outside DT[...]. - - * New DT[.(...)] syntax (in the style of package plyr) is identical to - DT[list(...)], DT[J(...)] and DT[data.table(...)]. We plan to add ..(), too, so - that .() and ..() are analogous to the file system's ./ and ../; i.e., .() - evaluates within the frame of DT and ..() in the parent scope. - - * New function rbindlist(l). This does the same as do.call(""rbind"",l), but much - faster. - -### BUG FIXES - - * DT[,f(.SD),by=colA] where f(x)=x[,colB:=1L] was a segfault, bug#1727. - This is now a graceful error to say that using := in .SD's j is - reserved for future use. This was already caught in most circumstances, - other than via f(.SD). Thanks to Leon Baum for reporting. Test added.","In simple terms, **`data.table`** is an R package used for handling tabular data (data organized in rows and columns). It is an **enhanced version** of the standard R `data.frame`. - -If you are familiar with spreadsheets or standard R data frames, here is why `data.table` is different: - -### 1. The Core Syntax: `DT[i, j, by]` -The most important thing to learn is its ""general form."" You can perform most tasks using this simple structure: -* **`i` (Where/Order by):** Which rows do you want? (e.g., ""all flights from JFK""). -* **`j` (Select/Update):** What do you want to do to the columns? (e.g., ""calculate the average delay""). -* **`by` (Group by):** How do you want to group the data? (e.g., ""grouped by each airline""). - -**Think of it like this:** Take `DT`, subset/reorder rows using `i`, then calculate `j`, grouped by `by`. - -### 2. Why use it? -* **Speed and Efficiency:** It is designed to be incredibly fast, even with very large datasets (e.g., 100GB in RAM). -* **Concise Syntax:** It allows you to do a lot of work with very little typing, which makes your code easier to read once you learn the basics. -* **Memory Efficient:** It can modify data ""by reference,"" meaning it updates your table directly without making unnecessary, memory-hungry copies. - -### 3. It plays well with others -Because `data.table` **inherits** from `data.frame`, it is compatible with almost all R functions and packages that expect a standard `data.frame`. You don't have to choose one or the other; you can use `data.table` alongside your other favorite R tools. - -### A Quick Example -If you have a table called `flights`, and you want to find the average delay for each origin airport, the code looks like this: - -```r -flights[, mean(dep_delay), by = origin] -``` - -To get started, you can simply type `vignette(""datatable-intro"", package=""data.table"")` in your R console.",100 -2026-02-11T12:08:58,1471221413766627340,tell me about data table,"HTML vignettes - -Introduction to data.table - -Reference semantics - -Keys and fast binary search based subsets - -Secondary indices and auto indexing - -Efficient reshaping using data.tables - -Frequently asked questions - -Documentation and examples - -?data.table - -?fread - -pdf manual - -devel html manual - -cheat sheet - -in-depth tables tutorial - -Questions & Answers - -community support on data.table stackoverflow tag - -Read [[Support]] wiki on how to properly ask questions and additional information about support. - -Notices/discussion - -Follow #rdatatable - -Click the 'watch' button at the top and right of this page (next to star and fork) - -User reviews - -Crantastic - -Learn by doing - -data.table course on DataCamp - ---- - -Provide an external link to the minimal reproducible file and use that file name in your code. - -Look at closed issues. Observe the good and the bad. - -Type ?data.table and look at all the arguments. Do you know them all? For example, do you know which= and others? Make sure you do. It is likely that one of them is there for your task. If some seem like they could help, search Stack Overflow for that argument name within the [data.table] tag and see how people have used it. Many answers use data.table but the question was not about data.table, so in this situation search in the [r] tag (not [data.table]) for the ""data.table"" and the argument name. - -Read all the vignettes. - -Read all the questions in the data.table FAQ even if you don't have those questions yet. - -Take the Datacamp course - -Best wishes! - ---- - -## Community - -`data.table` is widely used by the R community. It is being directly used by hundreds of CRAN and Bioconductor packages, and indirectly by thousands. It is one of the [top most starred](https://medium.datadriveninvestor.com/most-starred-and-forked-github-repos-for-r-in-data-science-fb87a54d2a6a) R packages on GitHub, and was highly rated by the [Depsy project](http://depsy.org/package/r/data.table). If you need help, the `data.table` community is active on [StackOverflow](https://stackoverflow.com/questions/tagged/data.table). - -A list of packages that significantly support, extend, or make use of `data.table` can be found in the [Seal of Approval](https://github.com/Rdatatable/data.table/blob/master/Seal_of_Approval.md) document. - -### Stay up-to-date - -- click the **Watch** button at the top and right of GitHub project page -- read [NEWS file](https://github.com/Rdatatable/data.table/blob/master/NEWS.md) -- follow [#rdatatable](https://x.com/hashtag/rdatatable) and the [r_data_table](https://x.com/r_data_table) account on X/Twitter -- follow [#rdatatable](https://fosstodon.org/tags/rdatatable) and the [r_data_table account](https://fosstodon.org/@r_data_table) on fosstodon -- follow the [data.table community page](https://www.linkedin.com/company/data-table-community) on LinkedIn -- watch recent [Presentations](https://github.com/Rdatatable/data.table/wiki/Presentations) -- read recent [Articles](https://github.com/Rdatatable/data.table/wiki/Articles) -- read posts on [The Raft](https://rdatatable-community.github.io/The-Raft/) - -### Contributing - -Guidelines for filing issues / pull requests: [Contribution Guidelines](https://github.com/Rdatatable/data.table/blob/master/.github/CONTRIBUTING.md). - ---- - -![Grouping, Illustrated](plots/grouping_illustration.png) - - -In the case of grouping, `.SD` is multiple in nature -- it refers to _each_ of these sub-`data.table`s, _one-at-a-time_ (slightly more accurately, the scope of `.SD` is a single sub-`data.table`). This allows us to concisely express an operation that we'd like to perform on _each sub-`data.table`_ before the re-assembled result is returned to us. - -This is useful in a variety of settings, the most common of which are presented here: - -## Group Subsetting - -Let's get the most recent season of data for each team in the Lahman data. This can be done quite simply with: - -```{r group_sd_last} -# the data is already sorted by year; if it weren't -# we could do Teams[order(yearID), .SD[.N], by = teamID] -Teams[ , .SD[.N], by = teamID] -``` - -Recall that `.SD` is itself a `data.table`, and that `.N` refers to the total number of rows in a group (it's equal to `nrow(.SD)` within each group), so `.SD[.N]` returns the _entirety of `.SD`_ for the final row associated with each `teamID`. - -Another common version of this is to use `.SD[1L]` instead to get the _first_ observation for each group, or `.SD[sample(.N, 1L)]` to return a _random_ row for each group. - -## Group Optima - -Suppose we wanted to return the _best_ year for each team, as measured by their total number of runs scored (`R`; we could easily adjust this to refer to other metrics, of course). Instead of taking a _fixed_ element from each sub-`data.table`, we now define the desired index _dynamically_ as follows: - -```{r sd_team_best_year} -Teams[ , .SD[which.max(R)], by = teamID] -``` - -Note that this approach can of course be combined with `.SDcols` to return only portions of the `data.table` for each `.SD` (with the caveat that `.SDcols` should be fixed across the various subsets). - -_NB_: `.SD[1L]` is currently optimized by [_`GForce`_](https://Rdatatable.gitlab.io/data.table/library/data.table/html/datatable-optimize.html) ([see also](https://stackoverflow.com/questions/22137591/about-gforce-in-data-table-1-9-2)), `data.table` internals which massively speed up the most common grouped operations like `sum` or `mean` -- see `?GForce` for more details and keep an eye on/voice support for feature improvement requests for updates on this front: [1](https://github.com/Rdatatable/data.table/issues/735), [2](https://github.com/Rdatatable/data.table/issues/2778), [3](https://github.com/Rdatatable/data.table/issues/523), [4](https://github.com/Rdatatable/data.table/issues/971), [5](https://github.com/Rdatatable/data.table/issues/1197), [6](https://github.com/Rdatatable/data.table/issues/1414). - -## Grouped Regression - -Returning to the inquiry above regarding the relationship between `ERA` and `W`, suppose we expect this relationship to differ by team (i.e., there's a different slope for each team). We can easily re-run this regression to explore the heterogeneity in this relationship as follows (noting that the standard errors from this approach are generally incorrect -- the specification `ERA ~ W*teamID` will be better -- this approach is easier to read and the _coefficients_ are OK): - ---- - -Instead, in *data.tables* we set and use `keys`. Think of a `key` as **supercharged rownames**. - -#### Keys and their properties {#key-properties} - -1. We can set keys on *multiple columns* and the column can be of *different types* -- *integer*, *numeric*, *character*, *factor*, *integer64* etc. *list* and *complex* types are not supported yet. - -2. Uniqueness is not enforced, i.e., duplicate key values are allowed. Since rows are sorted by key, any duplicates in the key columns will appear consecutively. - -3. Setting a `key` does *two* things: - - a. physically reorders the rows of the *data.table* by the column(s) provided *by reference*, always in *increasing* order. - - b. marks those columns as *key* columns by setting an attribute called `sorted` to the *data.table*. - - Since the rows are reordered, a *data.table* can have at most one key because it can not be sorted in more than one way. - -For the rest of the vignette, we will work with `flights` data set. - -### b) Set, get and use keys on a *data.table* - -#### -- How can we set the column `origin` as key in the *data.table* `flights`? - -```{r} -setkey(flights, origin) -head(flights) - -## alternatively we can provide character vectors to the function 'setkeyv()' -# setkeyv(flights, ""origin"") # useful to program with -``` - -* You can use the function `setkey()` and provide the column names (without quoting them). This is helpful during interactive use. - -* Alternatively you can pass a character vector of column names to the function `setkeyv()`. This is particularly useful while designing functions to pass columns to set key on as function arguments. - -* Note that we did not have to assign the result back to a variable. This is because like the `:=` function we saw in the [`vignette(""datatable-reference-semantics"", package=""data.table"")`](datatable-reference-semantics.html) vignette, `setkey()` and `setkeyv()` modify the input *data.table* *by reference*. They return the result invisibly. - -* The *data.table* is now reordered (or sorted) by the column we provided - `origin`. Since we reorder by reference, we only require additional memory of one column of length equal to the number of rows in the *data.table*, and is therefore very memory efficient. - -* You can also set keys directly when creating *data.tables* using the `data.table()` function using `key` argument. It takes a character vector of column names. - -#### set* and `:=`: - -In *data.table*, the `:=` operator and all the `set*` (e.g., `setkey`, `setorder`, `setnames` etc.) functions are the only ones which modify the input object *by reference*. - -Once you *key* a *data.table* by certain columns, you can subset by querying those key columns using the `.()` notation in `i`. Recall that `.()` is an *alias to* `list()`. - -#### -- Use the key column `origin` to subset all rows where the origin airport matches *""JFK""* - -```{r} -flights[.(""JFK"")] - -## alternatively -# flights[J(""JFK"")] (or) -# flights[list(""JFK"")] -``` - -* The *key* column has already been set to `origin`. So it is sufficient to provide the value, here *""JFK""*, directly. The `.()` syntax helps identify that the task requires looking up the value *""JFK""* in the key column of *data.table* (here column `origin` of `flights` *data.table*). - -* The *row indices* corresponding to the value *""JFK""* in `origin` is obtained first. And since there is no expression in `j`, all columns corresponding to those row indices are returned. - -* On single column key of *character* type, you can drop the `.()` notation and use the values directly when subsetting, like subset using row names on *data.frames*. - - ```r - flights[""JFK""] ## same as flights[.(""JFK"")] - ``` - -* We can subset any amount of values as required - - ```r - flights[c(""JFK"", ""LGA"")] ## same as flights[.(c(""JFK"", ""LGA""))] - ``` - - This returns all columns corresponding to those rows where `origin` column matches either *""JFK""* or *""LGA""*. - ---- - -2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk - -2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse - -2019.07 : Bayesian analysis with Stan & Data manipulation with data.table, Jared Kai Swan, Los Angeles East - -2019.07 : Start using data.table, Megan Stodel, Ministry of Justice Coffee and Coding - -2019.07 : Wrangling 4.6M rows of Financial Data (Home Loans Time Series) in R with data.table, Matt Dancho, Business Science Learning Lab - -2019.07 : data.table: a slide deck of data.table piping Gina Reynolds, slides - -2019.06 : why data.table?, Jan Gorecki, Poznan R User Group - -2019.05 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O Meetup Mountain View - -2019.05 : Workshop: Getting Started in R and data.table - Saghir Bashir, ilustat.com - -2019.04 : Pipes or Brackets: dplyr and data.table, Jeremy Guinta & Amy Linehan, satRday LA - -2019.02 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O World San Francisco - -2019.01 : Introduction to Automatic and Scalable Machine Learning with H2O and R (afternoon session data.table), Dmytro Perepolkin and Raoul Wolf, University of Oslo Library - -2018.12 : Workshop: Getting Started in R and data.table, Saghir Bashir, Data Science Unplugged Lisbon - -2018.10 : data.table for R, Python and updated-daily benchmarks, Matt Dowle, H2OWorld London - -2018.09 : Life in the Fast Lane: data.table Intro and Best Practices, Bill Gold, New York OSPM - -2018.09 : ALTREP from a data.table perspective, Matt Dowle, DSC Stanford I talked ad-lib and showed code on screen; no slides. - -2018.09 : Tutorial: efficient data manipulation with data.table, Jaap Walhout, uRos The Hague - -2018.08 : Success with OpenMP in R package data.table, Matt Dowle, JSM Vancouver - -2018.07 : 12 years of data.table (past, present and future), Arun Srinivasan, R in Montreal - -2018.07 : What's new in data.table, Jan Gorecki, WhyR Wroclaw - -2018.06 : Data munging in driverless.ai with datatable, Pasha Stetsenko, H2OWorld New York - -2018.05 : Top 10 reasons to use data.table; O Jossome, T Robert and F Meyer, dreamRs 2018 - -2018.05 : The beauty of data manipulation with data.table, János Divényi, eRum Budapest - -2017.12 : data.table, Matt Dowle, H2O World Mountain View - -2017.11 : data.table, Sebastian Jeworutzki, useR! Bochum - -2017.07 : data.table for beginners (tutorial), Arun Srinivasan, useR! Brussels - -2017.04 : Parallel fread and other news from data.table, Matt Dowle, Bay Area RUG - -2017.04 : data.table power hour, Steph Locke, SQLBits London - -2017.01 : New developments in the data.table package, Arun Srinivasan, AmstRdam RUG - -2016.09 : Data manipulation the #rdatatable way, Arun Srinivasan, SatRdays Budapest - -2016.07 : Parallel and distributed ordered join benchmark, Matt Dowle, H2O Open Tour New York - -2016.07 : Proposal for parallel sort in base R (and Python/Julia), Matt Dowle, DSC Stanford - -2016.06 : Efficient in-memory non-equi joins, Arun Srinivasan, useR! Stanford - -2016.06 : Ninja Moves with data.table 3hr tutorial, Matt Dowle & Arun Srinivasan, useR! Stanford - -2016.05 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin - -2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, Data by the Bay San Francisco - -2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, H2O Open Tour Chicago - -2016.05 : R Lecture #3: data.table, Peter Hurford - -2016.02 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin - -2016.02 Parallel and Distributed Joining, Matt Dowle, Bay Area R User Group - -2016.01 Invited lecture by Matt Dowle at Stat290 Paradigms for Computing with Data, Stanford - -2016.01 Invited lecture by Matt Dowle at FNCE3490 Data Science and Business Analytics, Santa Clara University - -2016.01 data table discussion, Gaurav Chaturedi & Nicholas Ng, Singapore R User Group - ---- - -## Importe optionnellement `data.table` : `Suggests` - -Si vous voulez utiliser `data.table` de manière conditionnelle, c'est-à-dire seulement quand il est installé, vous devriez utiliser `Suggests: data.table` dans votre fichier `DESCRIPTION` au lieu d'utiliser `Imports: data.table`. Par défaut, cette définition ne forcera pas l'installation de `data.table` lors de l'installation de votre package. Cela vous oblige aussi à utiliser conditionnellement `data.table` dans le code de votre package, ce qui doit être fait en utilisant la fonction `?requireNamespace`. L'exemple ci-dessous démontre l'utilisation conditionnelle de la fonction d'écriture de CSV rapide de `?fwrite` du package `data.table`. Si le package `data.table` n'est pas installé, la fonction de base R `?write.table`, beaucoup plus lente, est utilisée à la place. - -```r -my.write = function (x) { - if(requireNamespace(""data.table"", quietly=TRUE)) { - data.table::fwrite(x, ""data.csv"") - } else { - write.table(x, ""data.csv"") - } -} -``` - -Une version légèrement plus étendue de cette méthode permettrait également de s'assurer que la version installée de `data.table` est suffisamment récente pour que la fonction `fwrite` soit disponible : - -```r -my.write = function (x) { - if(requireNamespace(""data.table"", quietly=TRUE) && - utils::packageVersion(""data.table"") >= ""1.9.8"") { - data.table::fwrite(x, ""data.csv"") - } else { - write.table(x, ""data.csv"") - } -} -``` - -Lorsque vous utilisez un package comme dépendance suggérée, vous ne devez pas l'""importer"" dans le fichier `NAMESPACE`. Mentionnez-le simplement dans le fichier `DESCRIPTION`. Lorsque vous utilisez les fonctions `data.table` dans le code d'un package (fichiers R/*), vous devez utiliser le préfixe `data.table::` car aucune d'entre elles n'est importée. Lorsque vous utilisez `data.table` dans des packages de tests (par exemple des fichiers tests/testthat/test*), vous devez déclarer `.datatable.aware=TRUE` dans l'un des fichiers R/*. - -## `data.table` dans `Imports` mais rien d'importé - -Certains utilisateurs ([e.g.](https://github.com/Rdatatable/data.table/issues/2341)) peuvent préférer éviter d'utiliser `importFrom` ou `import` dans leur fichier `NAMESPACE` et utiliser à la place la syntaxe `data.table::` sur tout le code interne (en gardant bien sûr `data.table` sous leurs `Imports:` dans `DESCRIPTION`). - -Dans ce cas, la fonction non exportée `[.data.table` reviendra à appeler `[.data.frame` comme filet de sécurité puisque `data.table` n'a aucun moyen de savoir que le package parent est conscient qu'il tente de faire des appels en utilisant la syntaxe de l'API de requête de `data.table` (ce qui pourrait conduire à un comportement inattendu car la structure des appels à `[.data.frame` et `[.data.table` diffère fondamentalement, par exemple, ce dernier a beaucoup plus d'arguments). - -Si c'est l'approche que vous préférez pour le développement de packages, définissez `.datatable.aware = TRUE` n'importe où dans votre code source R (pas besoin d'exporter). Cela indique à `data.table` que vous, en tant que développeur du package, avez conçu votre code pour qu'il s'appuie intentionnellement sur les fonctionnalités de `data.table`, même si cela n'est pas évident en inspectant votre fichier `NAMESPACE`. - -`data.table` détermine à la volée si la fonction appelante est consciente qu'elle puise dans `data.table` avec la fonction interne `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), qui, en plus de vérifier le `?getNamespaceImports` de votre package, vérifie également l'existence de cette variable (entre autres choses). - -## Plus d'informations sur les dépendances - -Pour une documentation plus canonique sur la définition de la dépendance des packages, consultez le manuel officiel : [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html). - -## Importation des routines C de data.table - ---- - -# Seal of Approval - -This is a list of packages in the `data.table` community. - -Further detail about these packages and their relationship to `data.table` can be found at [The Raft blog](https://rdatatable-community.github.io/The-Raft/#category=seal%20of%20approval). - -To add your package to this list, please [submit a Pull Request to The Raft](https://github.com/rdatatable-community/The-Raft/), making sure to follow the templated instructions. - -## Extension packages - -Adds to the internal functionality of `data.table`. - -- [nc](https://github.com/tdhock/nc): Named capture regular expressions for text parsing and data reshaping. - -## Application packages - -Uses `data.table` to accomplish a particular task or analysis. - -- [mlr3](https://github.com/mlr-org/mlr3): A versatile machine learning framework built on data.table. - -## Bridge packages - -Translates `data.table` syntax to a different syntax, or provides helper functions for transitioning between `data.table` and another object type. - -- [tidyfast](https://github.com/TysonStanley/tidyfast): Fast and efficient alternatives to tidyr functions built on `data.table`. - -- [dtplyr](https://github.com/tidyverse/dtplyr): A `data.table` backend for `dplyr`. - -## Partner packages - -Not necessarily directly connected to `data.table`, but deliberately follows the [core philosophies of `data.table`](https://github.com/Rdatatable/data.table/blob/master/GOVERNANCE.md#the-r-package). - -- [collapse](https://github.com/SebKrantz/collapse): Advanced and Fast Data Transformation in R. - ---- - -Future talks - -Past talks - -2025.06.27: Toby Hocking, Time and memory efficient R programming, French slides for R Ladies Paris online meetup, video. - -2025.06.24: What makes R strong - Atelier Global Actuarial Conference, Zurich, Switzerland - by Jan Gorecki, slides. - -2025.05.19: Toby Hocking, French slides for data.table tutorial at Recontres R, Mons, Belgium, data.table pour la traitement efficace des grands jeux de données. - -2025.05.15: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Bernd Bischl's lab meeting at LMU in Munich, slides. - -2025.05.08: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Zurich Applied Statistics seminar, announcement, slides. - -2025.03: Toby Hocking, Short talk about data.table for Julie Josse lab in Montpellier, slides - -2025.02: Toby Hocking, Madrid R User Group, Video. - -2024.12: Toby Hocking, PyData Global, Dec 2024, Video. - -2024.11.07: R package dependencies in production - III Congress & XIV R User Conference, Sevilla, Spain - by Jan Gorecki, slides. - -2024.10.15: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, ""Women in Statistics and Data Science conference 2024"" Presentation Speed Talk and Poster Presentation - -2024.08.06: ""Creating a self-sustaining ecosystem for data.table"" by Ani, JSM 2024 (Portland, Oregon), Slides - -2024.08.06: Tyson S. Barrett, ""Efficient Tools for Your Tidy Workflow: A case for incorporating data.table"", JSM 2024 in Portland, OR slides - -2024.07.11: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, useR! 2024 online presentation video, useR! 2024 presentation in Salzburg, Austria slides - -2024.07.09: Tyson S. Barrett, ""The Past, Present, and Future of data.table"", useR! 2024 presentation in Salzburg, Austria slides - -2024.05.18: Tyson S. Barrett, ""data.table: New Developments"", R Finance 2024 presentation in Chicago slides - -2024.03.28: Toby Dylan Hocking, R Project in Google Summer of Code, virtual talk for Chicago R User Group, slides. - -2024.03.05: ""GitHub Actions: Automated performance regression testing on pull requests"" by Ani, NAU SICCS (Flagstaff, AZ), Slides - -2024.02.29: David Shilane, R Programming: Introduction to data.table, course at Conference on Statistical Practice (CSP2024), slides and practice exercises - -2024.02.08: intro to data.table at SevillaR: High productivity data frame operations with data.table, by Jan Gorecki, slides, video. - -2024.01.26: Rolling statistics - Edinburgh R user group meeting, Edinburgh, United Kingdom, by Jan Gorecki, slides - -2023.10.18: Using and contributing to the data.table package for efficient big data analysis - LatinR meeting, Montevideo, Uruguay. * Original presentation by Toby Dylan Hocking, google slides, source files. * Spanish translation by Mara Destefanis. - -2020.04: Manejo eficiente de grandes volúmenes de datos usando el paquete data.table en R - Nestor Montano, Diapositivas Youtube Playlist Facebook Playlist - -2020.04: Data wrangling and cleaning with data.table - Grant McDermott, Big Data in Economics (UOregon) - -2020.02.01: Machine Learning and Data Munging in H2O Driverless AI with (python) datatable - Parul Pandey, Hyderabad AI & DL meetup - -2020.01.30: List-columns in data.table - Tyson Barrett, rstudio::conf(2020L) - -2019.12.26: Efficiency in data processing. data.table basics - Jan Gorecki, R@IISA 2019 - -2019.10 : data.table for R and Python, Matt Dowle, H2OWorld New York - -2019.10 : Why I love data.table, Chris Mainey, Warwick R User Group - -2019.09 : Introduction to data.table, Jan Gorecki, whyR? Warsaw - -2019.07 : Not So Standard Deviations; 84 - All The Easy Issues, Hilary Parker and Roger Peng - -2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk - -2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse - ---- - -Para que data.table pueda heredar de `data.frame` sin usar `...`. Si usáramos `...`, no se detectarían los nombres de argumentos no válidos. - -El argumento `drop` nunca se utiliza en `[.data.table`. Es un marcador de posición para paquetes que no son compatibles con data.table cuando usan la sintaxis `[.data.frame` directamente en un data.table. - -## ¡Las uniones continuas son geniales y rapidísimas! ¿Fue difícil programarlas? - -La fila que prevalece en o antes de la fila `i` es la última fila que la búsqueda binaria prueba. Por lo tanto, `roll = TRUE` es básicamente un cambio en el código C de búsqueda binaria para devolver esa fila. - -## ¿Por qué `DT[i, col := value]` devuelve `DT` completo? Esperaba que no hubiera ningún valor visible (consistente con `<-`), o un mensaje o valor de retorno que indicara cuántas filas se actualizaron. No es evidente que los datos se hayan actualizado por referencia. - -Esto ha cambiado en la v1.8.3 para cumplir con sus expectativas. Actualice. - -Se devuelve la totalidad de `DT` (ahora de forma invisible) para que la sintaxis compuesta funcione; p. ej., `DT[i, done := TRUE][ , sum(done)]`. El número de filas actualizadas se devuelve cuando `verbose` es `TRUE`, ya sea por consulta o globalmente mediante `options(datatable.verbose = TRUE)`. - -## Bien, gracias. ¿Qué tenía de difícil que el resultado de `DT[i, col := valor]` se devolviera de forma invisible? - -R activa internamente la visibilidad para `[`. El valor de la columna eval de FunTab (ver [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) para `[` es `0`, lo que significa que se activa `R_Visible` (ver [R-Internals sección 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting)). Por lo tanto, al intentar `invisible()` o configurar `R_Visible` a `0` directamente, `eval` en [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) lo activaba de nuevo. - -Para solucionar este problema, la clave fue dejar de intentar detener la ejecución del método de impresión después de un `:=`. En su lugar, dentro de `:=` ahora (a partir de la v1.8.3) configuramos un indicador global que el método de impresión usa para determinar si imprimir o no. - -## ¿Por qué a veces tengo que escribir 'DT' dos veces después de usar ':=' para imprimir el resultado en la consola? - -Esta es una desventaja desafortunada para que [#869](https://github.com/Rdatatable/data.table/issues/869) funcione. Si se usa un `:=` dentro de una función sin `DT[]` antes del final de la función, la próxima vez que se escriba `DT` en el prompt, no se imprimirá nada. Un `DT` repetido se imprimirá. Para evitar esto: incluya un `DT[]` después del último `:=` en su función. Si eso no es posible (por ejemplo, no es una función que pueda cambiar), se garantiza que `print(DT)` y `DT[]` en el prompt se imprimirán. Como antes, agregar un `[]` adicional al final de la consulta `:=` es un modismo recomendado para actualizar y luego imprimir; por ejemplo, `DT[,foo:=3L][]`. - -## He observado que `base::cbind.data.frame` (y `base::rbind.data.frame`) parecen ser modificados por data.table. ¿Cómo es posible? ¿Por qué? - ---- - -# Moved here out from data.table.R on 10 Aug 2017. See data.table.R for history prior to that. - ---- - -Le mécanisme des options dans R est *global*. Cela signifie que si un utilisateur définit une option `data.table` pour son propre usage, ce réglage affecte également le code de tout package qui utilise `data.table`. Pour une option comme `datable.verbose`, c'est exactement le comportement désiré puisque le but est de tracer et d'enregistrer toutes les opérations de `data.table` d'où qu'elles viennent ; activer la verbosité n'affecte pas les résultats. Une autre option unique à R et excellente pour la production est `options(warn=2)` qui transforme tous les avertissements en erreurs. Encore une fois, le but est d'affecter n'importe quel avertissement dans n'importe quel package afin de ne manquer aucun avertissement en production. Il y a 6 options `datable.print.*` et 3 options d'optimisation qui n'affectent pas le résultat des opérations. Cependant, il y a une option `data.table` qui l'affecte et qui est maintenant un problème : `datatable.nomatch`. Cette option change la jointure par défaut d'externe à interne. [A côté de cela, la jointure par défaut est externe parce que outer est plus sûr ; il ne laisse pas tomber les données manquantes silencieusement ; de plus, il est cohérent avec la façon dont la base R fait correspondre les noms et les indices]. Certains utilisateurs préfèrent que la jointure interne soit la valeur par défaut et nous avons prévu cette option pour eux. Cependant, un utilisateur qui met en place cette option peut involontairement changer le comportement des jointures à l'intérieur des packages qui utilisent `data.table`. En conséquence, dans la version 1.12.4 (Oct 2019), un message était affiché lorsque l'option `datable.nomatch` était utilisée, et à partir de la version 1.14.2, elle est maintenant ignorée avec un avertissement. C'était la seule option `datable.table` qui posait ce problème. - -## Dépannage - -Si vous rencontrez des problèmes lors de la création d'un package qui utilise data.table, veuillez confirmer que le problème est reproductible dans une session R propre en utilisant la console R : `R CMD check nom.package`. - -Certains des problèmes les plus courants auxquels les développeurs sont confrontés sont généralement liés à des outils d'aide destinés à automatiser certaines tâches de développement de package, par exemple, l'utilisation de `roxygen` pour générer votre fichier `NAMESPACE` à partir des métadonnées des fichiers de code R. D'autres sont liés aux outils d'aide qui construisent et vérifient les package. D'autres sont liées aux aides qui construisent et vérifient le package. Malheureusement, ces aides ont parfois des effets secondaires inattendus/cachés qui peuvent masquer la source de vos problèmes. Ainsi, assurez-vous de faire une double vérification en utilisant la console R (lancez R sur la ligne de commande) et assurez-vous que l'importation est définie dans les fichiers `DESCRIPTION` et `NAMESPACE` en suivant les [instructions](#DESCRIPTION) [ci-dessus](#NAMESPACE). - -Si vous n'êtes pas en mesure de reproduire les problèmes que vous rencontrez en utilisant la simple console R pour construire (""build"") et vérifier (""check""), vous pouvez essayer d'obtenir de l'aide en vous basant sur les problèmes que nous avons rencontrés dans le passé avec `data.table` interagissant avec des outils d'aide : [devtools#192](https://github.com/r-lib/devtools/issues/192) ou [devtools#1472](https://github.com/r-lib/devtools/issues/1472). - -## Licence - -Depuis la version 1.10.5, `data.table` est sous licence Mozilla Public License (MPL). Les raisons du changement de la GPL peuvent être lues en entier [ici](https://github.com/Rdatatable/data.table/pull/2456) et vous pouvez en savoir plus sur la MPL sur Wikipedia [ici](https://en.wikipedia.org/wiki/Mozilla_Public_License) et [ici](https://en.wikipedia.org/wiki/Comparison_of_free_and_open-source_software_licenses). - -## Importe optionnellement `data.table` : `Suggests` - ---- - -Setting \code{options(datatable.verbose=TRUE)} will display various information about how rolling function processed. It will not print information in real-time but only at the end of the processing. -} -\value{ - For a non \emph{vectorized} input (\code{x} is not a list, and \code{n} specifies a single rolling window) a \code{vector} is returned, for convenience. Thus, rolling functions can be used conveniently within \code{data.table} syntax. For a \emph{vectorized} input a list is returned. -} -\note{ - Be aware that rolling functions operate on the physical order of input. If the intent is to roll values in a vector by a logical window, for example an hour, or a day, then one has to ensure that there are no gaps in the input, or use an adaptive rolling function to handle gaps, for which we provide helper function \code{\link{frolladapt}} to generate adaptive window size. -} -\section{\code{has.nf} argument}{ - \code{has.nf} can be used to speed up processing in cases when it is known if \code{x} contains (or not) non-finite values (\code{NA}, \code{NaN}, \code{Inf}, \code{-Inf}). - \itemize{ - \item Default \code{has.nf=NA} uses faster implementation that does not support non-finite values, but when non-finite values are detected it will re-run non-finite aware implementation. - \item \code{has.nf=TRUE} uses non-finite aware implementation straightaway. - \item \code{has.nf=FALSE} uses faster implementation that does not support non-finite values. Then depending on the rolling function it will either: - \itemize{ - \item (\emph{mean, sum, prod, var, sd}) detect non-finite, re-run non-finite aware. - \item (\emph{max, min, median}) does not detect non-finites and may silently produce an incorrect answer. - } - } - In general \code{has.nf=FALSE && any(!is.finite(x))} should be considered undefined behavior. Therefore \code{has.nf=FALSE} should be used with care. -} -\section{Implementation}{ - Most of the rolling functions have 4 different implementations. First factor that decides which implementation is used is the \code{adaptive} argument (either \code{TRUE} or \code{FALSE}), see section below for details. Then for each of those two algorithms there are usually two implementations depending on the \code{algo} argument. - \itemize{ - \item \code{algo=""fast""} uses \emph{""online""}, single pass, algorithm. - \itemize{ - \item \emph{max} and \emph{min} rolling function will not do only a single pass but, on average, they will compute \code{length(x)/n} nested loops. The larger the window, the greater the advantage over the \emph{exact} algorithm, which computes \code{length(x)} nested loops. Note that \emph{exact} uses multiple CPUs so for a small window sizes and many CPUs it may actually be faster than \emph{fast}. However, in such cases the elapsed timings will likely be far below a single second. - \item \emph{median} will use a novel algorithm described by \emph{Jukka Suomela} in his paper \emph{Median Filtering is Equivalent to Sorting (2014)}. See references section for the link. Implementation here is extended to support arbitrary length of input and an even window size. Despite extensive validation of results this function should be considered experimental. When missing values are detected it will fall back to slower \code{algo=""exact""} implementation. - \item \emph{var} and \emph{sd} will use numerically stable \emph{Welford}'s online algorithm. - \item Not all functions have \emph{fast} implementation available. As of now, adaptive \emph{max}, \emph{min}, \emph{median}, \emph{var} and \emph{sd} do not have \emph{fast} adaptive implementation, therefore it will automatically fall back to \emph{exact} adaptive implementation. Similarly, non-adaptive fast implementations of \emph{median}, \emph{var} and \emph{sd} will fall back to \emph{exact} implementations if they detect any non-finite values in the input. \code{datatable.verbose} option can be used to check that. - } - ---- - -### Testing - -`data.table` uses a series of unit tests to exhibit code that is expected to work. These are primarily stored in [`inst/tests/tests.Rraw`](https://github.com/Rdatatable/data.table/blob/master/inst/tests/tests.Rraw). They come primarily from two places -- when new features are implemented, the author constructs minimal examples demonstrating the expected common usage of said feature, including expected failures/invalid use cases (e.g., the [initial assay of `fwrite` included 24 tests](https://github.com/Rdatatable/data.table/pull/1613/files#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae)). Second, when kind users such as yourself happen upon some aberrant behavior in their everyday use of `data.table` (typically, some edge case that slipped through the cracks in the coding logic of the original author). We try to be thorough -- for example there were initially [141 tests of `split.data.table`](https://github.com/Rdatatable/data.table/commit/5f7a435fea5622bfbe1d5f1ffa99fa94a6a054ae#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae), and that number has since grown! - -When you file a pull request, you should add some tests to this file with this in mind -- for new features, try to cover possible use cases extensively (we use [Codecov](https://app.codecov.io/gh/Rdatatable/data.table) to make it a bit easier to see how well you've done to minimally cover any new code you've added); for bug fixes, include a minimal version of the problem you've identified and write a test to ensure that your fix indeed works, and thereby guarantee that your fix continues to work as the codebase is further modified in the future. We encourage you to scroll around in `tests.Rraw` a bit to get a feel for the types of examples that are being created, and how bugs are tested/features evaluated. - -What numbers should be used for new tests? Numbers should be new relative to current master at the time of your PR. If another PR is merged before yours, then there may be a conflict, but that is no problem, as [a Committer will fix the test numbers when merging your PR](https://github.com/Rdatatable/data.table/pull/4731#issuecomment-768858134). - -#### Using `test` - -See [`?test`](https://rdatatable.gitlab.io/data.table/reference/test.html). - -**References:** If you are not sure how to create a PR, but would like to contribute, these links should help get you started: - -1. **[How to Github: Fork, Branch, Track, Squash and Pull request](https://gun.io/blog/how-to-github-fork-branch-and-pull-request/)**. -1. **[Squashing Github pull requests into a single commit](http://eli.thegreenplace.net/2014/02/19/squashing-github-pull-requests-into-a-single-commit)**. -1. **[Github help](https://help.github.com/articles/using-pull-requests/)** - you'll need the *fork and pull* model. - -#### Performance testing - -If your PR may have an effect on time/memory usage, please consider adding a performance test, either in the same PR, or a follow-up PR. Note that first-time contributors _must_ do so in a follow-up PR, since the tests are only run on PRs from branches created directly in the Rdatatable/data.table repo. See the [Performance testing](https://github.com/Rdatatable/data.table/wiki/Performance-testing) wiki page for details. - -Minimal first time PR ---------------------- - -```shell -cd /tmp # or anywhere safe to play -git config --global core.autocrlf false # Windows-only preserve \n in test data -git clone https://github.com/Rdatatable/data.table.git -cd data.table -R CMD build . -R CMD check data.table_*.tar.gz -# ... -# Status: OK -``` - -Congratulations - you've just compiled and tested the very latest version of data.table in development. Everything looks good. Now make your changes. Using an editor of your choice, edit the appropriate `.R`, `.md`, `NEWS` and `tests.Rraw` files. Test your changes: - -```shell -rm data.table_*.tar.gz # clean-up old build(s) -R CMD build . -R CMD check data.table_*.tar.gz -``` - ---- - -15. `mult=""all""` -vs- `mult=""first""|""last""` now return consistent types and columns, [#340](https://github.com/Rdatatable/data.table/issues/340). Thanks to Michele Carriero for highlighting. - - 16. `duplicated.data.table` and `unique.data.table` gains `fromLast = TRUE/FALSE` argument, similar to base. Default value is FALSE. Closes [#347](https://github.com/Rdatatable/data.table/issues/347). - - 17. `anyDuplicated.data.table` is now implemented. Closes [#350](https://github.com/Rdatatable/data.table/issues/350). Thanks to M C (bluemagister) for reporting. - - 18. Complex j-expressions of the form `DT[, c(..., lapply(.SD, fun)), by=grp]`are now optimised as long as `.SD` is of the form `lapply(.SD, fun)` or `.SD`, `.SD[1]` or `.SD[1L]`. This resolves [#370](https://github.com/Rdatatable/data.table/issues/370). Thanks to Sam Steingold for reporting. - This also completes the first two task lists in [#735](https://github.com/Rdatatable/data.table/issues/735). - ```R - ## example: - DT[, c(.I, lapply(.SD, sum), mean(x), lapply(.SD, log)), by=grp] - ## is optimised to - DT[, list(.I, x=sum(x), y=sum(y), ..., mean(x), log(x), log(y), ...), by=grp] - ## and now... these variations are also optimised internally for speed - DT[, c(..., .SD, lapply(.SD, sum), ...), by=grp] - DT[, c(..., .SD[1], lapply(.SD, sum), ...), by=grp] - DT[, .SD, by=grp] - DT[, c(.SD), by=grp] - DT[, .SD[1], by=grp] # Note: but not yet DT[, .SD[1,], by=grp] - DT[, c(.SD[1]), by=grp] - DT[, head(.SD, 1), by=grp] # Note: but not yet DT[, head(.SD, -1), by=grp] - # but not yet optimised - DT[, c(.SD[a], .SD[x>1], lapply(.SD, sum)), by=grp] # where 'a' is, say, a numeric or a data.table, and also for expressions like x>1 - ``` - The underlying message is that `.SD` is being slowly optimised internally wherever possible, for speed, without compromising in the nice readable syntax it provides. - - 19. `setDT` gains `keep.rownames = TRUE/FALSE` argument, which works only on `data.frame`s. TRUE retains the data.frame's row names as a new column named `rn`. - - 20. The output of `tables()` now includes `NCOL`. Thanks to @dnlbrky for the suggestion. - - 21. `DT[, LHS := RHS]` (or its equivalent in `set`) now provides a warning and returns `DT` as it was, instead of an error, when `length(LHS) = 0L`, [#343](https://github.com/Rdatatable/data.table/issues/343). For example: - ```R - DT[, grep(""^b"", names(DT)) := NULL] # where no columns start with b - # warns now and returns DT instead of error - ``` - - 22. GForce now is also optimised for j-expression with `.N`. Closes [#334](https://github.com/Rdatatable/data.table/issues/334) and part of [#523](https://github.com/Rdatatable/data.table/issues/523). - ```R - DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.2 - doesn't know to use GForce - will be (relatively) slower - DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.3+ - will use GForce. - ``` - - 23. `setDF` is now implemented. It accepts a data.table and converts it to data.frame by reference, [#338](https://github.com/Rdatatable/data.table/issues/338). Thanks to canneff for the discussion on data.table mailing list. - - 24. `.I` gets named as `I` (instead of `.I`) wherever possible, similar to `.N`, [#344](https://github.com/Rdatatable/data.table/issues/344). - - 25. `setkey` on `.SD` is now an error, rather than warnings for each group about rebuilding the key. The new error is similar to when attempting to use `:=` in a `.SD` subquery: `"".SD is locked. Using set*() functions on .SD is reserved for possible future use; a tortuously flexible way to modify the original data by group.""` Thanks to Ron Hylton for highlighting the issue on datatable-help. - - 26. Looping calls to `unique(DT)` such as in `DT[,unique(.SD),by=group]` is now faster by avoiding internal overhead of calling `[.data.table`. Thanks again to Ron Hylton for highlighting on datatable-help. His example is reduced from 28 sec to 9 sec, with identical results. - ---- - -En este caso, la función no exportada `[.data.table` volverá a llamar a `[.data.frame` como medida de protección, ya que `data.table` no tiene forma de saber que el paquete padre es consciente de que está intentando realizar llamadas contra la sintaxis de la API de consulta de `data.table` (lo que podría generar un comportamiento inesperado ya que la estructura de las llamadas a `[.data.frame` y `[.data.table` difieren fundamentalmente, por ejemplo, este último tiene muchos más argumentos). - -Si este es su enfoque preferido para el desarrollo de paquetes, defina `.datatable.aware = TRUE` en cualquier parte de su código fuente de R (no es necesario exportar). Esto indica a `data.table` que usted, como desarrollador de paquetes, ha diseñado su código para que utilice intencionalmente su funcionalidad, aunque no sea evidente al inspeccionar su archivo `NAMESPACE`. - -`data.table` determina sobre la marcha si la función que llama es consciente de que está accediendo a `data.table` con la función interna `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), que, además de verificar `?getNamespaceImports` para su paquete, también verifica la existencia de esta variable (entre otras cosas). - -## Más información sobre las dependencias - -Para obtener documentación más canónica sobre la definición de dependencia de paquetes, consulte el manual oficial: [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html). - -## Importación de rutinas data.table C - -Algunas de las rutinas C utilizadas internamente ahora se exportan a nivel C, por lo que se pueden usar en paquetes R directamente desde su código C. Consulte [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) para obtener detalles y la sección [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) *Enlace a rutinas nativas en otros paquetes* para su uso. - -## Importación desde aplicaciones que no son r {#non-r-api} - -Algunas pequeñas partes del código C de `data.table` se aislaron de la API de RC y ahora pueden usarse desde aplicaciones que no sean de R mediante enlaces a archivos .so o .dll. Más adelante se proporcionarán detalles más concretos al respecto; por ahora, puede estudiar el código C aislado de la API de RC en [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) y [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c). - -## Cómo convertir su dependencia Depends en data.table a Imports - -Para convertir una dependencia `Depends` de `data.table` en una dependencia `Imports` en su paquete, siga estos pasos: - -### Paso 0. Asegúrese de que su paquete pase la verificación R CMD inicialmente - -### Paso 1. Actualice el archivo DESCRIPTION para colocar data.table en Imports, no en Depends - -**Antes:** - -```dcf -Depends: - R (>= 3.5.0), - data.table -Imports: -``` - -**Después:** - -```dcf -Depends: - R (>= 3.5.0) -Imports: - data.table -``` - -### Paso 2.1: Ejecutar `R CMD check` - -Ejecute `R CMD check` para identificar importaciones o símbolos faltantes. Este paso ayuda a: - -- Detecta automáticamente cualquier función o símbolo de `data.table` que no se importe explícitamente. -- Marca los símbolos especiales faltantes como `.N`, `.SD` y `:=`. -- Proporciona retroalimentación inmediata sobre lo que se debe agregar al archivo NAMESPACE. - -Nota: No todos estos usos son detectados por `R CMD check`. En particular, `R CMD check` omite algunos símbolos/funciones en fórmulas y no detecta expresiones analizadas como `parse(text = ""data.table(a = 1)"")`. Los paquetes necesitarán una buena cobertura de pruebas para detectar estos casos extremos. - -### Paso 2.2: Modificar el archivo NAMESPACE - -Según los resultados de `R CMD check`, asegúrese de que se importen todas las funciones utilizadas, los símbolos especiales, los genéricos S3 y las clases S4 de `data.table`. - ---- - -This is an internal list for me to get an idea of the type of Q that come up often, and how many Q could potentially benefit from non-equi joins.. (+ aggregate/update feature of data.table). These are the Q I've come across so far. - ---- - -## Où sont les archives de datatable-help ? - -La [page d'accueil](https://github.com/Rdatatable/data.table/wiki) contient des liens vers les archives en plusieurs formats. - -## Je préférerais ne pas publier sur la page ""Questions"" (Issues). Puis-je envoyer un email à une ou deux personnes ? - -Bien sûr, mais il est plus probable que vous obteniez une réponse plus rapide sur la page Issues ou sur Stack Overflow. De plus, le fait de poser des questions publiquement à ces endroits aide à construire la base de connaissances générale. - -## J'ai créé un package qui utilise data.table. Comment puis-je m'assurer que mon package est compatible avec data.table pour que l'héritage de `data.frame` fonctionne ? - -Voir [cette réponse](https://stackoverflow.com/a/10529888/403310). - -```{r, echo=FALSE} -setDTthreads(.old.th) -``` - ---- - -```{r} -DT = data.table( - ID = c(""b"",""b"",""b"",""a"",""a"",""c""), - a = 1:6, - b = 7:12, - c = 13:18 -) -DT -class(DT$ID) -``` - -Vous pouvez aussi convertir des objets existants en une `data.table` en utilisant `setDT()` (pour les structures `data.frame` et `list`) ou `as.data.table()` (pour les autres structures). Pour les autres détails concernant les différences (ce qui est hors du champ de cette vignette), voir `?setDT` et `?as.data.table`. - -#### Notez que : - -* Les numéros de ligne sont imprimés avec un `:` afin de séparer visuellement le numéro de ligne de la première colonne. - -* Lorsque le nombre de lignes à imprimer dépasse l'option globale `datatable.print.nrows` (défaut = `r getOption(""datatable.print.nrows"")`), il n'imprime automatiquement que les 5 premières et les 5 dernières lignes (comme on peut le voir dans la section [Data](#data)). Pour un grand `data.frame`, vous avez pu vous retrouver à attendre que des tables plus grandes s'impriment et se mettent en page, parfois sans fin. Cette restriction permet d'y remédier, et vous pouvez demander le nombre par défaut de la façon suivante : - - ```{.r} - getOption(""datatable.print.nrows"") - ``` - -* `data.table` ne définit ni n'utilise jamais de *nom de ligne*. Nous verrons pourquoi dans la [`vignette(""datatable-keys-fast-subset"", package=""data.table"")`](datatable-keys-fast-subset.html). - -### b) Forme générale - dans quel sens la 'data.table' est-elle *étendue* ? {#enhanced-1b} - -Par rapport à un `data.frame`, vous pouvez faire *beaucoup plus de choses* qu'extraire des lignes et sélectionner des colonnes dans la structure d'une `data.table`, par exemple, avec `[ ... ]` (Notez bien : nous pourrions aussi faire référence à écrire quelque chose dans `DT[...]` comme ""interroger `DT`"", par analogie ou similairement à SQL). Pour le comprendre il faut d'abord que nous regardions la *forme générale* de la syntaxe `data.table`, comme indiqué ci-dessous : - -```r -DT[i, j, by] - -## R: i j by -## SQL: where | order by select | update group by -``` - -Les utilisateurs ayant des connaissances SQL feront peut être directement le lien avec cette syntaxe. - -#### La manière de le lire (à haute voix) est : - -Utiliser `DT`, extraire ou trier les lignes en utilisant `i`, puis calculer `j`, grouper avec `by`. - -Commençons par voir 'i' et 'j' d'abord - en indiçant les lignes et en travaillant sur les colonnes. - -### c) Regrouper les lignes en 'i' {#subset-i-1c} - -#### -- Obtenir tous les vols qui ont ""JFK"" comme aéroport de départ pendant le mois de juin. - -```{r} -ans <- flights[origin == ""JFK"" & month == 6L] -head(ans) -``` - -* Dans le cadre d'un `data.table`, on peut se référer aux colonnes *comme s'il s'agissait de variables*, un peu comme dans SQL ou Stata. Par conséquent, nous nous référons simplement à `origin` et `month` comme s'il s'agissait de variables. Nous n'avons pas besoin d'ajouter le préfixe `vol$` à chaque fois. Néanmoins, l'utilisation de `flights$origin` et `flights$month` fonctionnerait parfaitement. - -* Les *indices de ligne* qui satisfont la condition `origin == ""JFK"" & month == 6L` sont calculés, et puisqu'il n'y a rien d'autre à faire, toutes les colonnes de `flights` aux lignes correspondant à ces *indices de ligne* sont simplement renvoyées sous forme d’un `data.table`. - -* Une virgule après la condition dans `i` n'est pas nécessaire. Mais `flights[origin == ""JFK"" & month == 6L, ]` fonctionnerait parfaitement. Avec un `data.frame`, cependant, la virgule est indispensable. - -#### -- Récupérer les deux premières lignes de `flights`. {#subset-rows-integer} - -```{r} -ans <- flights[1:2] -ans -``` - -* Dans ce cas, il n'y a pas de condition. Les indices des lignes sont déjà fournis dans `i`. Nous retournons donc un `data.table` avec toutes les colonnes de `flights` aux lignes pour ces *index de ligne*. - -#### -- Trier `flights` d'abord sur la colonne `origin` dans l'ordre *ascending*, puis par `dest` dans l'ordre *descendant* : - ---- - -### NOTES - - 1. Clearer explanation of what `duplicated()` does (borrowed from base). Thanks to @matthieugomez for pointing out. Closes [#872](https://github.com/Rdatatable/data.table/issues/872). - - 2. `?setnames` has been updated now that `names<-` and `colnames<-` shallow (rather than deep) copy from R >= 3.1.0, [#853](https://github.com/Rdatatable/data.table/issues/853). - - 3. [FAQ 1.6](https://github.com/Rdatatable/data.table/wiki/vignettes/datatable-faq.pdf) has been embellished, [#517](https://github.com/Rdatatable/data.table/issues/517). Thanks to a discussion with Vivi and Josh O'Brien. - - 4. `data.table` redefines `melt` generic and *suggests* `reshape2` instead of *import*. As a result we don't have to load `reshape2` package to use `melt.data.table` anymore. The reason for this change is that `data.table` requires R >=2.14, whereas `reshape2` R v3.0.0+. Reshape2's melt methods can be used without any issues by loading the package normally. - - 5. `DT[, j, ]` at times made an additional (unnecessary) copy. This is now fixed. This fix also avoids allocating `.I` when `j` doesn't use it. As a result `:=` and other subset operations should be faster (and use less memory). Thanks to @szilard for the nice report. Closes [#921](https://github.com/Rdatatable/data.table/issues/921). - - 6. Because `reshape2` requires R >3.0.0, and `data.table` works with R >= 2.14.1, we can not import `reshape2` anymore. Therefore we define a `melt` generic and `melt.data.table` method for data.tables and redirect to `reshape2`'s `melt` for other objects. This is to ensure that existing code works fine. - - 7. `dcast` is also a generic now in data.table. So we can use `dcast(...)` directly, and don't have to spell it out as `dcast.data.table(...)` like before. The `dcast` generic in data.table redirects to `reshape2::dcast` if the input object is not a data.table. But for that you have to load `reshape2` before loading `data.table`. If not, reshape2's `dcast` overwrites data.table's `dcast` generic, in which case you will need the `::` operator - ex: `data.table::dcast(...)`. - - NB: Ideal situation would be for `dcast` to be a generic in reshape2 as well, but it is not. We have issued a [pull request](https://github.com/hadley/reshape/pull/62) to make `dcast` in reshape2 a generic, but that has not yet been accepted. - - 8. Clarified the use of `bit64::integer4` in `merge.data.table()` and `setNumericRounding()`. Closes [#1093](https://github.com/Rdatatable/data.table/issues/1093). Thanks to @sfischme for the report. - - 9. Removed an unnecessary (and silly) `giveNames` argument from `setDT()`. Not sure why I added this in the first place! - - 10. `options(datatable.prettyprint.char=5L)` restricts the number of characters to be printed for character columns. For example: - ``` - options(datatable.prettyprint.char = 5L) - DT = data.table(x=1:2, y=c(""abcdefghij"", ""klmnopqrstuv"")) - DT - # x y - # 1: 1 abcde... - # 2: 2 klmno... - ```` - - 11. `rolltolast` argument in `[.data.table` is now defunct. It was deprecated in 1.9.4. - - 12. `data.table`'s dependency has been moved forward from R 2.14.0 to R 2.14.1, now nearly 4 years old (Dec 2011). As usual before release to CRAN we ensure data.table passes the test suite on the stated dependency and keep this as old as possible for as long as possible. As requested by users in managed environments. For this reason we still don't use `paste0()` internally, since that was added to R 2.15.0. - - 13. Warning about `datatable.old.bywithoutby` option (for grouping on join without providing `by`) being deprecated in the next release is in place now. Thanks to @jangorecki for the PR. - - 14. Fixed `allow.cartesian` documentation to `nrow(x)+nrow(i)` instead of `max(nrow(x), nrow(i))`. Closes [#1123](https://github.com/Rdatatable/data.table/issues/1123). - -## data.table v1.9.4 (on CRAN 2 Oct 2014) - -### NEW FEATURES - ---- - -Package: data.table -Version: 1.18.99 -Title: Extension of `data.frame` -Depends: R (>= 3.5.0) -Imports: methods -Suggests: bit64 (>= 4.0.0), R.utils, xts, zoo (>= 1.8-1), yaml, litedown, codetools -Enhances: knitr, xfun -Description: Fast aggregation of large data (e.g. 100GB in RAM), fast ordered joins, fast add/modify/delete of columns by group using no copies at all, list columns, friendly and fast character-separated-value read/write. Offers a natural and flexible syntax, for faster development. -License: MPL-2.0 | file LICENSE -URL: https://r-datatable.com, https://Rdatatable.gitlab.io/data.table, https://github.com/Rdatatable/data.table -BugReports: https://github.com/Rdatatable/data.table/issues -VignetteBuilder: litedown -Encoding: UTF-8 -ByteCompile: TRUE -Authors@R: c( - person(""Tyson"",""Barrett"", role=c(""aut"",""cre""), email=""t.barrett88@gmail.com"", comment = c(ORCID=""0000-0002-2137-1391"")), - person(""Matt"",""Dowle"", role=""aut"", email=""mattjdowle@gmail.com""), - person(""Arun"",""Srinivasan"", role=""aut"", email=""asrini@pm.me""), - person(""Jan"",""Gorecki"", role=""aut"", email=""j.gorecki@wit.edu.pl""), - person(""Michael"",""Chirico"", role=""aut"", email=""michaelchirico4@gmail.com"", comment = c(ORCID=""0000-0003-0787-087X"")), - person(""Toby"",""Hocking"", role=""aut"", email=""toby.hocking@r-project.org"", comment = c(ORCID=""0000-0002-3146-0865"")), - person(""Benjamin"",""Schwendinger"",role=""aut"", comment = c(ORCID=""0000-0003-3315-8114"")), - person(""Ivan"", ""Krylov"", role=""aut"", email=""ikrylov@disroot.org"", comment = c(ORCID=""0000-0002-0172-3812"")), - person(""Pasha"",""Stetsenko"", role=""ctb""), - person(""Tom"",""Short"", role=""ctb""), - person(""Steve"",""Lianoglou"", role=""ctb""), - person(""Eduard"",""Antonyan"", role=""ctb""), - person(""Markus"",""Bonsch"", role=""ctb""), - person(""Hugh"",""Parsonage"", role=""ctb""), - person(""Scott"",""Ritchie"", role=""ctb""), - person(""Kun"",""Ren"", role=""ctb""), - person(""Xianying"",""Tan"", role=""ctb""), - person(""Rick"",""Saporta"", role=""ctb""), - person(""Otto"",""Seiskari"", role=""ctb""), - person(""Xianghui"",""Dong"", role=""ctb""), - person(""Michel"",""Lang"", role=""ctb""), - person(""Watal"",""Iwasaki"", role=""ctb""), - person(""Seth"",""Wenchel"", role=""ctb""), - person(""Karl"",""Broman"", role=""ctb""), - person(""Tobias"",""Schmidt"", role=""ctb""), - person(""David"",""Arenburg"", role=""ctb""), - person(""Ethan"",""Smith"", role=""ctb""), - person(""Francois"",""Cocquemas"", role=""ctb""), - person(""Matthieu"",""Gomez"", role=""ctb""), - person(""Philippe"",""Chataignon"", role=""ctb""), - person(""Nello"",""Blaser"", role=""ctb""), - person(""Dmitry"",""Selivanov"", role=""ctb""), - person(""Andrey"",""Riabushenko"", role=""ctb""), - person(""Cheng"",""Lee"", role=""ctb""), - person(""Declan"",""Groves"", role=""ctb""), - person(""Daniel"",""Possenriede"", role=""ctb""), - person(""Felipe"",""Parages"", role=""ctb""), - person(""Denes"",""Toth"", role=""ctb""), - person(""Mus"",""Yaramaz-David"", role=""ctb""), - person(""Ayappan"",""Perumal"", role=""ctb""), - person(""James"",""Sams"", role=""ctb""), - person(""Martin"",""Morgan"", role=""ctb""), - person(""Michael"",""Quinn"", role=""ctb""), - person(given=""@javrucebo"", role=""ctb"", comment=""GitHub user""), - person(""Marc"",""Halperin"", role=""ctb""), - person(""Roy"",""Storey"", role=""ctb""), - person(""Manish"",""Saraswat"", role=""ctb""), - person(""Morgan"",""Jacob"", role=""ctb""), - person(""Michael"",""Schubmehl"", role=""ctb""), - person(""Davis"",""Vaughan"", role=""ctb""), - person(""Leonardo"",""Silvestri"", role=""ctb""), - person(""Jim"",""Hester"", role=""ctb""), - person(""Anthony"",""Damico"", role=""ctb""), - person(""Sebastian"",""Freundt"", role=""ctb""), - person(""David"",""Simons"", role=""ctb""), - person(""Elliott"",""Sales de Andrade"", role=""ctb""), - ---- - -## Why `data.table`? - -* concise syntax: fast to type, fast to read -* fast speed -* memory efficient -* careful API lifecycle management -* community -* feature rich - -## Features - -* fast and friendly delimited **file reader**: **[`?fread`](https://rdatatable.gitlab.io/data.table/reference/fread.html)**, see also [convenience features for _small_ data](https://github.com/Rdatatable/data.table/wiki/Convenience-features-of-fread) -* fast and feature rich delimited **file writer**: **[`?fwrite`](https://rdatatable.gitlab.io/data.table/reference/fwrite.html)** -* low-level **parallelism**: many common operations are internally parallelized to use multiple CPU threads -* fast and scalable aggregations; e.g. 100GB in RAM (see [benchmarks](https://duckdblabs.github.io/db-benchmark/) on up to **two billion rows**) -* fast and feature rich joins: **ordered joins** (e.g. rolling forwards, backwards, nearest and limited staleness), **[overlapping range joins](https://github.com/Rdatatable/data.table/wiki/talks/EARL2014_OverlapRangeJoin_Arun.pdf)** (similar to `IRanges::findOverlaps`), **[non-equi joins](https://github.com/Rdatatable/data.table/wiki/talks/ArunSrinivasanUseR2016.pdf)** (i.e. joins using operators `>, >=, <, <=`), **aggregate on join** (`by=.EACHI`), **update on join** -* fast add/update/delete columns **by reference** by group using no copies at all -* fast and feature rich **reshaping** data: **[`?dcast`](https://rdatatable.gitlab.io/data.table/reference/dcast.data.table.html)** (_pivot/wider/spread_) and **[`?melt`](https://rdatatable.gitlab.io/data.table/reference/melt.data.table.html)** (_unpivot/longer/gather_) -* **any R function from any R package** can be used in queries not just the subset of functions made available by a database backend, also columns of type `list` are supported -* has **[no dependencies](https://en.wikipedia.org/wiki/Dependency_hell)** at all other than base R itself, for simpler production/maintenance -* the R dependency is **as old as possible for as long as possible**, currently R 3.5.0 (2018), and we continuously test against that version - -## Installation - -```r -install.packages(""data.table"") - -# latest development version (only if newer available) -data.table::update_dev_pkg() - -# latest development version (force install) -install.packages(""data.table"", repos=""https://rdatatable.gitlab.io/data.table"") -``` - -See [the Installation wiki](https://github.com/Rdatatable/data.table/wiki/Installation) for more details. - -## Usage - -Use `data.table` subset `[` operator the same way you would use `data.frame` one, but... - -* no need to prefix each column with `DT$` (like `subset()` and `with()` but built-in) -* any R expression using any package is allowed in `j` argument, not just list of columns -* extra argument `by` to compute `j` expression by group - -```r -library(data.table) -DT = as.data.table(iris) - -# FROM[WHERE, SELECT, GROUP BY] -# DT [i, j, by] - -DT[Petal.Width > 1.0, mean(Petal.Length), by = Species] -# Species V1 -#1: versicolor 4.362791 -#2: virginica 5.552000 -``` - -### Getting started - -* [Introduction to data.table](https://cran.r-project.org/package=data.table/vignettes/datatable-intro.html) vignette -* [Getting started](https://github.com/Rdatatable/data.table/wiki/Getting-started) wiki page -* [Examples](https://rdatatable.gitlab.io/data.table/reference/data.table.html#examples) produced by `example(data.table)` - -### Cheatsheets - - - -## Community - ---- - -# Governance for the R data.table project - -# Purpose and scope - -## This document - -The purpose of this document is to define how people related to the project work together, so that the project can expand to handle a larger and more diverse group of contributors. - -## The R package - -The purpose of the project is to maintain the R data.table package, which is guided by the following principles: - -* Time & memory efficiency -* Concise syntax (minimal redundancy in code) -* No external Imports/LinkingTo/Depends dependencies (external meaning those not maintained by the project) -* Few (if any) Suggests/Enhances dependencies -* Stable code base (strong preference for user-friendly back-compatibility with data.table itself and with old versions of R) -* Comprehensive and accessible documentation and run-time signals (errors, warnings) - -To prioritize developer time, we define what is in and out of current scope. Feature requests in issues and pull requests that are out of current scope should be closed immediately, because they are not the current priority. If someone wants to contribute code that is currently out of scope, they first have to make a pull request that changes the scope as defined below. - -The current scope of package functionality includes: -* data manipulation and analysis - * reshaping/pivoting - * aggregation/summarizing (via `[,, by=...]` and _grouping sets_) - * filtering rows - * all sorts of joins - * adding/updating/deleting columns - * set operations (union/rbind, intersection, difference) -* high-performance common functions (`frank`, `fcase`, `fifelse`, `transpose`, `chmatch`, `fsort`, `forder`, `uniqueN`, ...) -* common convenience functions (`%like%`, `%notin%`, `timetaken`, `substitute2`, ...) -* ordered data functions (`rleid`, `shift`, `fcoalesce`, _locf_/_nocb_ `nafill`, rolling functions) -* date and time related classes and functions (`IDate`, `ITime`) -* technical functions (`address`, `tables`, `update_dev_pkg`) -* Reading/writing of data from/to flat (plain text) files like CSV - -Functionality that is out of current scope: -* Plotting/graphics (like ggplot2) -* Manipulating out-of-memory data, e.g. data stored on disk or remote SQL DB, (as opposed e.g. to sqldf / dbplyr) -* Machine learning (like mlr3) -* Reading/writing of data from/to binary files like parquet - -# Roles - -## Contributor - -* Definition: a user who has written/commented at least one issue, worked to label/triage issues, written a blog post, given a talk, etc. -* How this role is recognized: there is no central list of Contributors / no formal recognition for Contributors. - -## Project Member - -* Definition: some one who has submitted at least one PR with substantial contributions, that has been merged into master. PRs improving documentation are welcome, and substantial contributions to the docs should count toward Project Membership, but minor contributions such as spelling fixes do not count toward Project Membership. -* How to obtain this role: anybody can become a Project Member by submitting a PR with substantial contributions, then having it reviewed and merged into master. Contributors who have written issues should be encouraged to submit their first PR to become a Project Member. Contributors can look at https://github.com/Rdatatable/data.table/labels/beginner-task for easy issues to work on. -* How this role is recognized: Project Members are credited via role=""ctb"" in DESCRIPTION (so they appear in Author list on CRAN), and they are added to https://github.com/orgs/Rdatatable/teams/project-members so they can create new branches in the Rdatatable/data.table GitHub repo. They also appear on https://github.com/Rdatatable/data.table/graphs/contributors (Contributions to master, excluding merge commits). - -## Reviewer - ---- - -Ainsi, data.table peut hériter de `data.frame` sans utiliser `...`. Si nous utilisions `...`, les noms d'arguments invalides ne seraient pas détectés. - -L'argument `drop` n'est jamais utilisé par `[.data.table`. C'est un substitut pour les packages non compatibles avec data.table lorsqu'ils utilisent la syntaxe `[.data.frame` directement sur un data.table. - -## Les jonctions par roulement sont cool et très rapides ! C'était difficile à programmer ? - -La ligne dominante sur ou avant la ligne `i` est la ligne finale que la recherche binaire teste de toute façon. Donc `roll = TRUE` est essentiellement un interrupteur dans le code C de la recherche binaire pour retourner cette ligne. - -## Pourquoi `DT[i, col := valeur]` retourne-t-il la totalité de `DT` ? Je m'attendais à ce qu'il n'y ait pas de valeur visible (ce qui est cohérent avec `<-`), ou à ce qu'il y ait un message ou une valeur de retour contenant le nombre de lignes mises à jour. Il n'est pas évident que les données aient été mises à jour par référence. - -Ceci a été modifié dans la version 1.8.3 pour répondre à vos attentes. Veuillez mettre à jour. - -L'ensemble de `DT` est retourné (maintenant de manière invisible) pour que la syntaxe composée puisse fonctionner ; *e.g.*, `DT[i, done := TRUE][ , sum(done)]`. Le nombre de lignes mises à jour est retourné quand `verbose` est `TRUE`, soit sur une base par requête, soit globalement en utilisant `options(datatable.verbose = TRUE)`. - -## D'accord, merci. Qu'y a-t-il de si difficile dans le fait que le résultat de `DT[i, col := value]` soit renvoyé de façon invisible ? - -R force en interne la visibilité pour `[`. La valeur de la colonne eval de FunTab (voir [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) pour `[` est `0` ce qui signifie ""force `R_Visible` on"" (voir [R-Internals section 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting) ). Par conséquent, lorsque nous avons essayé `invisible()` ou de mettre `R_Visible` à `0` directement nous-mêmes, `eval` dans [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) l'a forcé à nouveau. - -Pour résoudre ce problème, la clé était de ne plus essayer d'arrêter l'exécution de la méthode print après un `:=`. Au lieu de cela, à l'intérieur de `:=` nous mettons maintenant (à partir de la version 1.8.3) un drapeau global que la méthode print utilise pour savoir si elle doit imprimer ou non. - -## Pourquoi dois-je taper `DT` parfois deux fois après avoir utilisé `:=` pour imprimer le résultat dans la console ? - -C'est un inconvénient malheureux pour faire fonctionner [#869](https://github.com/Rdatatable/data.table/issues/869). Si un `:=` est utilisé à l'intérieur d'une fonction sans `DT[]` avant la fin de la fonction, alors la prochaine fois que `DT` est tapé à l'invite, rien ne sera affiché. Un `DT` répété sera affiché. Pour éviter cela : incluez un `DT[]` après le dernier `:=` dans votre fonction. Si ce n'est pas possible (par exemple, ce n'est pas une fonction que vous pouvez changer), alors `print(DT)` et `DT[]` à l'invite sont garantis de s’afficher. Comme précédemment, l'ajout d'un `[]` supplémentaire à la fin de la requête `:=` est un idiome recommandé pour mettre à jour et ensuite imprimer ; e.g.> `DT[,foo:=3L][]`. - -## J'ai remarqué que `base::cbind.data.frame` (et `base::rbind.data.frame`) semble être modifié par data.table. Comment cela est-il possible ? Pourquoi ? - ---- - -#include ""data.table.h"" - ---- - -#include ""data.table.h"" - ---- - -3. `DT[col > val, head(.SD, 1), by = ...]` - объединяет `i` с `j` и - `by`. - -#### Также не забывайте: - -Если `j` возвращает `list`, каждый элемент этого списка станет столбцом в -результирующей `data.table`. - -В [следующем руководстве (`vignette(""datatable-reference-semantics"", -package=""data.table"")`)](../datatable-reference-semantics.html) мы -рассмотрим, как *добавлять/обновлять/удалять* столбцы *по ссылке* и как -комбинировать эти операции с `i` и `by`. - -*** - -```{r, echo=FALSE} -setDTthreads(.old.th) -``` - ---- - -## OK, je commence à comprendre ce qu'est data.table, mais pourquoi n'avez-vous pas simplement amélioré `data.frame` dans R ? Pourquoi faut-il que ce soit un nouveau package ? - -Comme [souligné ci-dessus] (#j-num), `j` dans `[.data.table` est fondamentalement différent de `j` dans `[.data.frame`. Même si quelque chose d'aussi simple que `DF[ , 1]` était modifié dans la base R pour retourner un data.frame plutôt qu'un vecteur, cela casserait le code existant dans des milliers de package CRAN et dans le code utilisateur. Dès que nous avons pris la décision de créer une nouvelle classe héritant de data.frame, nous avons eu l'opportunité de changer certaines choses et nous l'avons fait. Nous voulons que data.table soit légèrement différent et qu'il fonctionne de cette façon pour que la syntaxe plus compliquée fonctionne. Il existe également d'autres différences (voir [ci-dessous](#PetitesDifférences) ). - -De plus, data.table *hérite* de `data.frame`. C'est aussi un `data.frame`. Un data.table peut être passé à n'importe quel package qui n'accepte que `data.frame` et ce package peut utiliser la syntaxe `[.data.frame` sur le data.table. Voir [cette réponse] (https://stackoverflow.com/a/10529888/403310) pour savoir comment procéder. - -Nous avons également proposé des améliorations à R chaque fois que cela était possible. L'une d'entre elles a été acceptée comme nouvelle fonctionnalité dans R 2.12.0 : - -> `unique()` et `match()` sont maintenant plus rapides sur les vecteurs de caractères où tous les éléments sont dans le cache global CHARSXP et ont un encodage non marqué (ASCII). Merci à Matt Dowle pour avoir suggéré des améliorations dans la façon dont le code de hachage est généré dans unique.c. - -Une deuxième proposition était d'utiliser `memcpy` dans duplicate.c, qui est beaucoup plus rapide qu'une boucle for en C. Cela améliorerait la *manière* dont R copie les données en interne (sur certaines mesures, de 13 fois). Le fil de discussion sur r-devel est [ici] (https://stat.ethz.ch/pipermail/r-devel/2010-April/057249.html). - -Une troisième proposition plus significative qui a été acceptée est que R utilise maintenant le code de tri par base (radix sort) de data.table à partir de R 3.3.0 : - -> L'algorithme de tri par base (radix sort) et l'implémentation de data.table (forder) remplace l'ancien tri par base (comptage) et ajoute une nouvelle méthode pour order(). Proposé par Matt Dowle et Arun Srinivasan, le nouvel algorithme supporte les vecteurs de logiques, d’entiers (même avec de grandes valeurs), de réels et de caractères. Il est plus performant que toutes les autres méthodes, mais il y a quelques mises en garde (voir ?sort). - -C'était un grand événement pour nous et nous l'avons fêté jusqu'à ce que les vaches rentrent à la maison. (Pas vraiment.) - -## Pourquoi les valeurs par défaut sont-elles telles qu'elles sont ? Pourquoi le système fonctionne-t-il comme il le fait ? - -La réponse est simple : l'auteur principal l'a conçu à l'origine pour son propre usage. C'est ce qu'il voulait. Il trouve que c'est une façon plus naturelle et plus rapide d'écrire du code, qui s'exécute également plus rapidement. - -## N'est-ce pas déjà fait par `with()` et `subset()` dans `base` ? - -Certaines des caractéristiques discutées jusqu'à présent sont, oui. Le package s'appuie sur la fonctionnalité de base. Il fait le même genre de choses, mais avec moins de code et s'exécute beaucoup plus rapidement s'il est utilisé correctement. - -## Pourquoi `X[Y]` retourne-t-il aussi toutes les colonnes de `Y` ? Ne devrait-elle pas retourner un sous-ensemble de `X` ? - ---- - -El caso de los símbolos especiales de `data.table` (p. ej., `.SD` y `.N`) y el operador de asignación (`:=`) es ligeramente diferente (consulte `?.N` para obtener más información, incluyendo una lista completa de dichos símbolos). Debe importar cualquiera de estos valores que utilice del espacio de nombres de `data.table` para evitar problemas derivados del improbable escenario de que cambiemos el valor exportado de estos en el futuro. Por ejemplo, si desea usar `.N`, `.I` y `:=`, un `NAMESPACE` mínimo tendría: - -```r -importFrom(data.table, .N, .I, ':=') -``` - -Mucho más simple es simplemente usar `import(data.table)`, lo que permitirá el uso en el código de su paquete de cualquier objeto exportado desde `data.table`. - -Si no le importa tener `id` y `grp` registrados como variables globales en el espacio de nombres de su paquete, puede usar `?globalVariables`. Tenga en cuenta que estas notas no afectan el código ni su funcionalidad; si no va a publicar su paquete, puede simplemente ignorarlas. - -## Se debe tener cuidado al proporcionar y utilizar `options` - -Una práctica común en los paquetes de R es proporcionar opciones de personalización definidas por `options(name=val)` y obtenidas mediante `getOption(""name"", default)`. Los argumentos de función suelen especificar una llamada a `getOption()` para que el usuario conozca (a través de `?fun` o `args(fun)`) el nombre de la opción que controla el valor predeterminado para ese parámetro; por ejemplo, `fun(..., verbose=getOption(""datatable.verbose"", FALSE))`. Todas las opciones de `data.table` comienzan con `datatable.` para evitar conflictos con las opciones de otros paquetes. El usuario simplemente llama a `options(datatable.verbose=TRUE)` para activar la verbosidad. Esto afecta a todas las llamadas a la función data.table, a menos que `verbose=FALSE` se especifique explícitamente; por ejemplo, `fun(..., verbose=FALSE)`. - -El mecanismo de opciones en R es *global*. Esto significa que si un usuario establece una opción `data.table` para su propio uso, esa configuración también afecta al código dentro de cualquier paquete que también esté usando `data.table`. Para una opción como `datatable.verbose`, este es exactamente el comportamiento deseado ya que el deseo es rastrear y registrar todas las operaciones de `data.table` desde donde sea que se originen; activar la verbosidad no afecta los resultados. Otra opción única de R y excelente para producción es `options(warn=2)` de R que convierte todas las advertencias en errores. Nuevamente, el deseo es afectar cualquier advertencia en cualquier paquete para no perder ninguna advertencia en producción. Hay 6 opciones `datatable.print.*` y 3 opciones de optimización que no afectan el resultado de las operaciones. Sin embargo, hay una opción `data.table` que sí afecta y ahora es una preocupación: `datatable.nomatch`. Esta opción cambia la unión predeterminada de externa a interna. [Aparte, la unión predeterminada es externa porque externa es más segura; no elimina los datos faltantes silenciosamente; Además, es coherente con el método R básico para la coincidencia por nombres e índices. Algunos usuarios prefieren que la unión interna sea la opción predeterminada, y les proporcionamos esta opción. Sin embargo, si un usuario configura esta opción, puede cambiar involuntariamente el comportamiento de las uniones dentro de paquetes que usan `data.table`. Por consiguiente, en la versión 1.12.4 (octubre de 2019) se mostraba un mensaje al usar la opción `datatable.nomatch`, y a partir de la versión 1.14.2, se ignora con una advertencia. Era la única opción de `data.table` con este problema. - -## Solución de problemas - -Si enfrenta algún problema al crear un paquete que usa data.table, confirme que el problema se pueda reproducir en una sesión R limpia usando la consola R: `R CMD check package.name`. - ---- - -12. Clarified `with=FALSE` as suggested in [#513](https://github.com/Rdatatable/data.table/issues/513). - - 13. Clarified `.I` in `?data.table`. Closes [#510](https://github.com/Rdatatable/data.table/issues/510). Thanks to Gabor for reporting. - - 14. Moved `?copy` to its own help page, and documented that `dt_names <- copy(names(DT))` is necessary for `dt_names` to be not modified by reference as a result of updating `DT` by reference (e.g. adding a new column by reference). Closes [#512](https://github.com/Rdatatable/data.table/issues/512). Thanks to Zach for [this SO question](https://stackoverflow.com/q/15913417/559784) and user1971988 for [this SO question](https://stackoverflow.com/q/18662715/559784). - - 15. `address(x)` doesn't increment `NAM()` value when `x` is a vector. Using the object as argument to a non-primitive function is sufficient to increment its reference. Closes #824. Thanks to @tarakc02 for the [question on twitter](https://twitter.com/tarakc02/status/513796515026837504) and hint from Hadley. - ---- - -## data.table v1.9.2 (on CRAN 27 Feb 2014) - -### NEW FEATURES - - 1. Fast methods of `reshape2`'s `melt` and `dcast` have been implemented for `data.table`, **FR #2627**. Most settings are identical to `reshape2`, see `?melt.data.table.` - > `melt`: 10 million rows and 5 columns, 61.3 seconds reduced to 1.2 seconds. - > `dcast`: 1 million rows and 4 columns, 192 seconds reduced to 3.6 seconds. - - * `melt.data.table` is also capable of melting on columns of type `list`. - * `melt.data.table` gains `variable.factor` and `value.factor` which by default are TRUE and FALSE respectively for compatibility with `reshape2`. This allows for directly controlling the output type of ""variable"" and ""value"" columns (as factors or not). - * `melt.data.table`'s `na.rm = TRUE` parameter is optimised to remove NAs directly during melt and therefore avoids the overhead of subsetting using `!is.na` afterwards on the molten data. - * except for `margins` argument from `reshape2:::dcast`, all features of dcast are intact. `dcast.data.table` can also accept `value.var` columns of type list. - - > Reminder of Cologne (Dec 2013) presentation **slide 32** : [""Why not submit a dcast pull request to reshape2?""](https://github.com/Rdatatable/data.table/wiki/talks/CologneR_2013.pdf). - - 2. Joins scale better as the number of rows increases. The binary merge used to start on row 1 of i; it now starts on the middle row of i. Many thanks to Mike Crowe for the suggestion. This has been done within column so scales much better as the number of join columns increase, too. - - > Reminder: bmerge allows the rolling join feature: forwards, backwards, limited and nearest. - - 3. Sorting (`setkey` and ad-hoc `by=`) is faster and scales better on randomly ordered data and now also adapts to almost sorted data. The remaining comparison sorts have been removed. We use a combination of counting sort and forwards radix (MSD) for all types including double, character and integers with range>100,000; forwards not backwards through columns. This was inspired by [Terdiman](https://codercorner.com/RadixSortRevisited.htm) and [Herf's](http://stereopsis.com/radix.html) (LSD) radix approach for floating point : - - 4. `unique` and `duplicated` methods for `data.table` are significantly faster especially for type numeric (i.e. double), and type integer where range > 100,000 or contains negatives. - - 5. `NA`, `NaN`, `+Inf` and `-Inf` are now considered distinct values, may be in keys, can be joined to and can be grouped. `data.table` defines: `NA` < `NaN` < `-Inf`. Thanks to Martin Liberts for the suggestions, #4684, #4815 and #4883. - ---- - -# Test case created directly using the atime code below (not adapted from any other benchmark), based on the PR, Removes unnecessary data.table call from as.data.table.array https://github.com/Rdatatable/data.table/pull/7010 - ""as.data.table.array improved in #7010"" = atime::atime_test( - setup = { - dims = c(N, 1, 1) - arr = array(seq_len(prod(dims)), dim=dims) - }, - expr = data.table:::as.data.table.array(arr, na.rm=FALSE), - Slow = ""73d79edf8ff8c55163e90631072192301056e336"", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/8397dc3c993b61a07a81c786ca68c22bc589befc) - Fast = ""8397dc3c993b61a07a81c786ca68c22bc589befc""), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7019/commits) that removes inefficiency - - ""isoweek improved in #7144"" = atime::atime_test( - setup = { - set.seed(349) - x = sample(Sys.Date() - 0:5000, N, replace=TRUE) - }, - expr = data.table::isoweek(x), - Slow = ""548410d23dd74b625e8ea9aeb1a5d2e9dddd2927"", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/548410d23dd74b625e8ea9aeb1a5d2e9dddd2927) - Fast = ""c0b32a60466bed0e63420ec105bc75c34590865e""), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7144/commits) that uses a much faster implementation - - # Regression introduced in #7404 (grouped by factor). - ""DT[by] max regression fixed in #7480"" = atime::atime_test( - N = as.integer(10^seq(3, 5, by=0.5)), - setup = { - dt = data.table( - id = as.factor(rep(seq_len(N), each = 100L)), - V1 = 1L - ) - }, - expr = data.table:::`[.data.table`(dt, , base::max(V1, na.rm = TRUE), by = id), - Before = ""476de7e3"", - Regression = ""6f49bf1"", - Fixed = ""b6ad1a4"", - seconds.limit = 1), - tests=extra.test.list) -# nolint end: undesirable_operator_linter. - ---- - -Running comparative performance benchmarks to portray the relative efficiency of operations, i.e., in contrast to other packages that achieve similar functionality as data.table. - -Writing open-source material like blog posts to document such (with code to run the benchmarks provisioned therein), as they would tend to be a great resource for the community. Examples: df-atime-figures, df-partial-match - -Designing test scenarios to measure performance, such as handling large datasets, performing complex queries, having concurrent operations, etc. - -Staying informed with the latest developments in R programming and performance testing methodologies to bring such updates to data.table. - ---- - -These articles either focus on data.table (bold) or mention/use it (perhaps only briefly and you may need to search the article for ""data.table""), ordered by date. If you know of an article that may be of interest to others, please add it here (). You can also search all articles from the R blogosphere since c. 2009 on http://www.r-bloggers.com/. There is no filter applied: if the article exists and mentions data.table, positively or negatively, it is included on this page. Please watch out for benchmarks measured in milliseconds.** Comparisons on such small scales often do not hold when scaled up to larger data because, for example, they over-represent call overhead and/or the dataset is so small it fits in CPU cache. A test repetition count (e.g. ntimes=) of 5 or more is often an indication that the test data size is too small. Please check that setkey() has been used and its time reported separately. Tutorials, slides and videos are over on the Videos & Slides page. - -(**) all pages on this wiki have no write restrictions. You are encouraged to change content in this wiki yourself as you see fit. Changes will go live immediately with no oversight by any project member. If you spot any abuse, please check the edit history to see who made the edit and please inform us. - ---- - -```{r} -DT = data.table( - ID = c(""b"",""b"",""b"",""a"",""a"",""c""), - a = 1:6, - b = 7:12, - c = 13:18 -) -DT -class(DT$ID) -``` - -También puede convertir objetos existentes a una tabla `data.table` mediante `setDT()` (para estructuras `data.frame` y `list`) o `as.data.table()` (para otras estructuras). Para más detalles sobre la diferencia (que excede el alcance de este artículo), consulte `?setDT` y `?as.data.table`. - -#### Tenga en cuenta que: - -* Los números de fila se imprimen con un `:` para separar visualmente el número de fila de la primera columna. - -* Cuando el número de filas a imprimir excede la opción global `datatable.print.nrows` (predeterminado = `r getOption(""datatable.print.nrows"")`), se imprimen automáticamente solo las 5 primeras y las 5 últimas filas (como se puede ver en la sección [Data](#data)). Con un `data.frame` grande, es posible que haya tenido que esperar mientras tablas más grandes se imprimen y paginan, a veces sin parar. Esta restricción ayuda con esto, y puede consultar el número predeterminado de la siguiente manera: - - ```{.r} - getOption(""datatable.print.nrows"") - ``` - -* `data.table` nunca establece ni usa *nombres de fila*. Veremos por qué en la viñeta [`vignette(""datatable-keys-fast-subset"", package=""data.table"")`](datatable-keys-fast-subset.html). - -### b) Forma general: ¿de qué manera se *mejora* una `data.table`? {#enhanced-1b} - -A diferencia de un `data.frame`, se puede hacer *mucho más* que simplemente filtrar filas y seleccionar columnas dentro del marco de un `data.table`, es decir, dentro de `[ ... ]` (Nota: también podríamos referirnos a escribir dentro de `DT[...]` como ""consultar `DT`"", como analogía o en relación con SQL). Para comprenderlo, primero debemos analizar la *forma general* de la sintaxis de `data.table`, como se muestra a continuación: - -```r -DT[i, j, by] - -## R: i j by -## SQL: where | order by select | update group by -``` - -Los usuarios con conocimientos de SQL probablemente se sentirán inmediatamente identificados con esta sintaxis. - -#### La forma de leerlo (en voz alta) es: - -Tomar `DT`, filtrar/reordenar filas usando `i`, luego calcular `j`, agrupado por `by`. - -Comencemos mirando primero `i` y `j`: filtrando filas y operando en columnas. - -### c) Filtrar filas en `i` {#subset-i-1c} - -#### -- Obtenga todos los vuelos con ""JFK"" como aeropuerto de origen en el mes de junio. - -```{r} -ans <- flights[origin == ""JFK"" & month == 6L] -head(ans) -``` - -* Dentro de una tabla `data.table`, se puede hacer referencia a las columnas *como si fueran variables*, de forma similar a SQL o Stata. Por lo tanto, simplemente nos referimos a `origin` y `month` como si fueran variables. No es necesario añadir el prefijo `flights$` cada vez. Sin embargo, usar `flights$origin` y `flights$month` funcionaría perfectamente. - -* Se calculan los *índices de fila* que satisfacen la condición `origin == ""JFK"" & month == 6L` y, como no queda nada más por hacer, todas las columnas de `flights` en las filas correspondientes a esos *índices de fila* simplemente se devuelven como una `data.table`. - -* No se requiere una coma después de la condición en `i`. Pero `flights[origin == ""JFK"" & month == 6L, ]` funcionaría perfectamente. Sin embargo, en un `data.frame`, la coma es necesaria. - -#### -- Obtener las dos primeras filas de `vuelos`. {#subset-rows-integer} - -```{r} -ans <- flights[1:2] -ans -``` - -* En este caso, no hay ninguna condición. Los índices de fila ya se proporcionan en `i`. Por lo tanto, devolvemos una `data.table` con todas las columnas de `flights` en las filas para esos *índices de fila*. - -#### -- Ordena `vuelos` primero por la columna `origen` en orden *ascendente*, y luego por `dest` en orden *descendente*: - -Podemos utilizar la función R `order()` para lograr esto. - -```{r} -ans <- flights[order(origin, -dest)] -head(ans) -``` - -#### `order()` está optimizado internamente - ---- - -9. `print.data.table()` (all via master issue [#1523](https://github.com/Rdatatable/data.table/issues/1523)): - - * gains `print.keys` argument, `FALSE` by default, which displays the keys and/or indices (secondary keys) of a `data.table`. Thanks @MichaelChirico for the PR, Yike Lu for the suggestion and Arun for honing that idea to its present form. - - * gains `col.names` argument, `""auto""` by default, which toggles which registers of column names to include in printed output. `""top""` forces `data.frame`-like behavior where column names are only ever included at the top of the output, as opposed to the default behavior which appends the column names below the output as well for longer (>20 rows) tables. `""none""` shuts down column name printing altogether. Thanks @MichaelChirico for the PR, Oleg Bondar for the suggestion, and Arun for guiding commentary. - - * list columns would print the first 6 items in each cell followed by a comma if there are more than 6 in that cell. Now it ends "",..."" to make it clearer, part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). Thanks to @franknarf1 for drawing attention to an issue raised on Stack Overflow by @TMOTTM [here](https://stackoverflow.com/q/47679701). - -10. `setkeyv` accelerated if key already exists [#2331](https://github.com/Rdatatable/data.table/issues/2331). Thanks to @MarkusBonsch for the PR. - -11. Keys and indexes are now partially retained up to the key column assigned to with ':=' [#2372](https://github.com/Rdatatable/data.table/issues/2372). They used to be dropped completely if any one of the columns was affected by `:=`. Tanks to @MarkusBonsch for the PR. - -12. Faster `as.IDate` and `as.ITime` methods for `POSIXct` and `numeric`, [#1392](https://github.com/Rdatatable/data.table/issues/1392). Thanks to Jan Gorecki for the PR. - -13. `unique(DT)` now returns `DT` early when there are no duplicates to save RAM, [#2013](https://github.com/Rdatatable/data.table/issues/2013). Thanks to Michael Chirico for the PR, and thanks to @mgahan for pointing out a reversion in `na.omit.data.table` before release, [#2660](https://github.com/Rdatatable/data.table/issues/2660#issuecomment-371027948). - -14. `uniqueN()` is now faster on logical vectors. Thanks to Hugh Parsonage for [PR#2648](https://github.com/Rdatatable/data.table/pull/2648). - - ```R - N = 1e9 - # was now - x = c(TRUE,FALSE,NA,rep(TRUE,N)) # - uniqueN(x) == 3 # 5.4s 0.00s - x = c(TRUE,rep(FALSE,N), NA) # - uniqueN(x,na.rm=TRUE) == 2 # 5.4s 0.00s - x = c(rep(TRUE,N),FALSE,NA) # - uniqueN(x) == 3 # 6.7s 0.38s - ``` - -15. Subsetting optimization with keys and indices is now possible for compound queries like `DT[a==1 & b==2]`, [#2472](https://github.com/Rdatatable/data.table/issues/2472). -Thanks to @MichaelChirico for reporting and to @MarkusBonsch for the implementation. - -16. `melt.data.table` now offers friendlier functionality for providing `value.name` for `list` input to `measure.vars`, [#1547](https://github.com/Rdatatable/data.table/issues/1547). Thanks @MichaelChirico and @franknarf1 for the suggestion and use cases, @jangorecki and @mrdwab for implementation feedback, and @MichaelChirico for ultimate implementation. - -17. `update.dev.pkg` is new function to update package from development repository, it will download package sources only when newer commit is available in repository. `data.table::update.dev.pkg()` defaults updates `data.table`, but any package can be used. - -18. Item 1 in NEWS for [v1.10.2](https://github.com/Rdatatable/data.table/blob/master/NEWS.md#changes-in-v1102--on-cran-31-jan-2017) on CRAN in Jan 2017 included : - ---- - -# one and two+ row cases of data.table, as.data.table and cbind involving list columns, given -# the change to tests 1613.571-3 in PR#3471 in v1.12.4 -# in v1.12.2 and before : -# data.table( data.table(1:2), list(c(""a"",""b""),""a"") ) -# V1 V2 NA -# -# 1: 1 a a -# 2: 2 b a -# i.e. passing a data.table() to data.table() changed the meaning of list() which was inconsistent, -# and an NA column name was introduced too (a bug in itself) -# from v1.12.4 : -# V1 V2 -# -# 1: 1 a,b -# 2: 2 a -# i.e. now easier to add the list column as intended, and it's consistent with -# basic (i.e. not cbind-like) usage of data.table() -# # changed in v1.12.4 ? -ans = data.table(V1=1, V2=2) # -------------------- -test(2058.01, data.table( data.table(1), 2), ans) # no -test(2058.02, as.data.table(list(data.table(1), 2)), ans) # no -test(2058.03, cbind(data.table(1), 2), ans) # no -ans = data.table(V1=1, V2=list(2)) # 'basic' usage; i.e. not cbind-like -test(2058.04, sapply(ans, class), c(V1=""numeric"", V2=""list"")) # no -test(2058.05, data.table( data.table(1), list(2) ), ans) # yes -test(2058.06, as.data.table(list(data.table(1), list(2))), ans) # yes -test(2058.07, cbind(data.table(1), list(2)), ans) # yes -ans = data.table(V1=1:2, V2=list(c(""a"",""b""),""a"")) -test(2058.08, sapply(ans, class), c(V1=""integer"", V2=""list"")) # no -test(2058.09, data.table( data.table(1:2), list(c(""a"",""b""),""a"") ), ans) # yes -test(2058.10, as.data.table(list(data.table(1:2), list(c(""a"",""b""),""a""))), ans) # yes -test(2058.11, cbind(data.table(1:2), list(c(""a"",""b""),""a"")), ans) # yes -test(2058.12, cbind(first=data.table(A=1:3), second=data.table(A=4, B=5:7)), - data.table(first.A=1:3, second.A=4, second.B=5:7)) # no -test(2058.13, cbind(data.table(A=1:3), second=data.table(A=4, B=5:7)), - data.table(A=1:3, second.A=4, second.B=5:7)) # no -test(2058.14, cbind(data.table(A=1,B=2),3), data.table(A=1,B=2,V2=3)) # no -L = list(1:3, 4:6) -test(2058.15, as.data.table(L), data.table(V1=1:3, V2=4:6)) # no -# retain all-blank list names as batchtools relies on in reg$defs[1,job.pars], #3581 -names(L) = c("""","""") -test(2058.16, as.data.table(L), setnames(data.table(1:3, 4:6),c("""",""""))) # no -# retain existing duplicate and blank names of a plain-list, just as 1.12.2 did -L = list(1:3, 4:6, 7:9, 10:12) -names(L) = c("""",""foo"","""",""foo"") -test(2058.17, as.data.table(L), - setnames(data.table(1:3, 4:6, 7:9, 10:12),c("""",""foo"","""",""foo""))) # no -L = list(1:3, NULL, 4:6) -test(2058.18, length(L), 3L) -test(2058.19, as.data.table(L), data.table(V1=1:3, V2=4:6)) # V2 not V3 # no -DT = data.table(a=1:3, b=c(4,5,6)) -test(2058.20, DT[,b:=list(NULL)], data.table(a=1:3)) # no - ---- - -## fichier `NAMESPACE` {#NAMESPACE} - -La prochaine chose à faire est de définir le contenu de `data.table` que votre package utilise. Cela doit être fait dans le fichier `NAMESPACE`. Le plus souvent, les auteurs de package voudront utiliser `import(data.table)` qui importera toutes les fonctions exportées (c'est-à-dire listées dans le fichier `NAMESPACE` de `data.table`) de `data.table`. - -Vous pouvez aussi ne vouloir utiliser qu'un sous-ensemble des fonctions de `data.table` ; par exemple, certains packages peuvent simplement utiliser les fonctions d'écriture et lecture CSV haute performance de `data.table`, pour lesquelles vous pouvez ajouter `importFrom(data.table, fread, fwrite)` dans votre fichier `NAMESPACE`. Il est également possible d'importer toutes les fonctions d'un package *en excluant* certaines d'entre elles en utilisant `import(data.table, except=c(fread, fwrite))`. - -Assurez-vous de lire également la note sur l'évaluation non standard dans `data.table` dans [la section sur les ""globales non définies""](#globals) - -## Utilisation - -A titre d'exemple, nous allons définir deux fonctions dans le package `a.pkg` qui utilise `data.table`. Une fonction, `gen`, générera un simple `data.table` ; une autre, `aggr`, en fera une simple agrégation. - -```r -gen = function (n = 100L) { - dt = as.data.table(list(id = seq_len(n))) - dt[, grp := ((id - 1) %% 26) + 1 - ][, grp := letters[grp] - ][] -} -aggr = function (x) { - stopifnot( - is.data.table(x), - ""grp"" %in% names(x) - ) - x[, .N, by = grp] -} -``` - -## Tests - -Assurez-vous d'inclure des tests dans votre package. Avant chaque version majeure de `data.table`, nous vérifions les dépendances inverses. Cela signifie que si un changement dans `data.table` casse votre code, nous serons capables de repérer les changements et de vous en informer avant de publier la nouvelle version. Cela suppose bien sûr que vous publiiez votre package sur CRAN ou Bioconductor. Le test le plus basique peut être un script R en clair dans le répertoire `tests/test.R` de votre package : - -```r -library(a.pkg) -dt = gen() -stopifnot(nrow(dt) == 100) -dt2 = aggr(dt) -stopifnot(nrow(dt2) < 100) -``` - -Lorsque vous testez votre package, vous pouvez utiliser `R CMD check --no-stop-on-test-error`, qui continuera après une erreur et exécutera tous vos tests (au lieu de s'arrêter à la première ligne du script qui a échoué). - -## Tester en utilisant `testthat` - -Il est très courant d'utiliser le package `testthat` pour effectuer des tests. Tester un package qui importe `data.table` n'est pas différent de tester d'autres packages. Un exemple de script de test `tests/testthat/test-pkg.R` : - -```r -context(""pkg tests"") - -test_that(""generate dt"", { expect_true(nrow(gen()) == 100) }) -test_that(""aggregate dt"", { expect_true(nrow(aggr(gen())) < 100) }) -``` - -Si `data.table` est dans Suggests (mais pas dans Imports) alors vous devez déclarer `.datatable.aware=TRUE` dans un des fichiers R/* pour éviter les erreurs ""object not found"" lors des tests via `testthat::test_package` ou `testthat::test_check`. - -## Traitement des ""fonctions ou variables globales indéfinies"" (""undefined global functions or variables"") {#globals} - -l'utilisation par `data.table` de l'évaluation différée de R (en particulier sur le côté gauche de `:=`) n'est pas bien reconnue par `R CMD check`. Il en résulte des `NOTE`s comme la suivante lors de la vérification du package : - -``` -* checking R code for possible problems ... NOTE -aggr: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'id' -Undefined global functions or variables: -grp id -``` - ---- - -Thank you for contributing to data.table! - -Please be sure to read our [CONTRIBUTING guide](CONTRIBUTING.md). In particular, ""Contributors are requested not to use code assistants if they are not able to evaluate license of the code provided by an assistant, and to provide proper citation."" - - - ---- - -3. `print` method for `data.table` gains `trunc.cols` argument (and corresponding option `datatable.print.trunc.cols`, default `FALSE`), [#1497](https://github.com/Rdatatable/data.table/issues/1497), part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). This prints only as many columns as fit in the console without wrapping to new lines (e.g., the first 5 of 80 columns) and a message that states the count and names of the variables not shown. When `class=TRUE` the message also contains the classes of the variables. `data.table` has always automatically truncated _rows_ of a table for efficiency (e.g. printing 10 rows instead of 10 million); in the future, we may do the same for _columns_ (e.g., 10 columns instead of 20,000) by changing the default for this argument. Thanks to @nverno for the initial suggestion and to @TysonStanley for the PR. - -4. `setnames(DT, new=new_names)` (i.e. explicitly named `new=` argument) now works as expected rather than an error message requesting that `old=` be supplied too, [#4041](https://github.com/Rdatatable/data.table/issues/4041). Thanks @Kodiologist for the suggestion. - -5. `nafill` and `setnafill` gain `nan` argument to say whether `NaN` should be considered the same as `NA` for filling purposes, [#4020](https://github.com/Rdatatable/data.table/issues/4020). Prior versions had an implicit value of `nan=NaN`; the default is now `nan=NA`, i.e., `NaN` is treated as if it's missing. Thanks @AnonymousBoba for the suggestion. Also, while `nafill` still respects `getOption('datatable.verbose')`, the `verbose` argument has been removed. - -6. New function `fcase(...,default)` implemented in C by Morgan Jacob, [#3823](https://github.com/Rdatatable/data.table/issues/3823), is inspired by SQL `CASE WHEN` which is a common tool in SQL for e.g. building labels or cutting age groups based on conditions. `fcase` is comparable to R function `dplyr::case_when` however it evaluates its arguments in a lazy way (i.e. only when needed) as shown below. Please see `?fcase` for more details. - - ```R - # Lazy evaluation - x = 1:10 - data.table::fcase( - x < 5L, 1L, - x >= 5L, 3L, - x == 5L, stop(""provided value is an unexpected one!"") - ) - # [1] 1 1 1 1 3 3 3 3 3 3 - - dplyr::case_when( - x < 5L ~ 1L, - x >= 5L ~ 3L, - x == 5L ~ stop(""provided value is an unexpected one!"") - ) - # Error in eval_tidy(pair$rhs, env = default_env) : - # provided value is an unexpected one! - - # Benchmark - x = sample(1:100, 3e7, replace = TRUE) # 114 MB - microbenchmark::microbenchmark( - dplyr::case_when( - x < 10L ~ 0L, - x < 20L ~ 10L, - x < 30L ~ 20L, - x < 40L ~ 30L, - x < 50L ~ 40L, - x < 60L ~ 50L, - x > 60L ~ 60L - ), - data.table::fcase( - x < 10L, 0L, - x < 20L, 10L, - x < 30L, 20L, - x < 40L, 30L, - x < 50L, 40L, - x < 60L, 50L, - x > 60L, 60L - ), - times = 5L, - unit = ""s"") - # Unit: seconds - # expr min lq mean median uq max neval - # dplyr::case_when 11.57 11.71 12.22 11.82 12.00 14.02 5 - # data.table::fcase 1.49 1.55 1.67 1.71 1.73 1.86 5 - ``` - -7. `.SDcols=is.numeric` now works; i.e., `SDcols=` accepts a function which is used to select the columns of `.SD`, [#3950](https://github.com/Rdatatable/data.table/issues/3950). Any function (even _ad hoc_) that returns scalar `TRUE`/`FALSE` for each column will do; e.g., `.SDcols=!is.character` will return _non_-character columns (_a la_ `Negate()`). Note that `.SDcols=patterns(...)` can still be used for filtering based on the column names. - ---- - -* Integer-based date and time-of-day classes have been - introduced. This allows dates and times to be used as keys - more easily. See as.IDate, as.ITime, and IDateTime. - Conversions to and from POSIXct, Date, and chron are - supported. - - * [<-.data.table and $<-.data.table were revised to check for - changes to the key-ed columns. [<-.data.table also now allows - data.table-style indexing for i. Both of these changes may - introduce incompatibilities for existing code. - - * Logical columns are now allowed in keys and in 'by', as are expressions - that evaluate to logical. Thanks to David Winsemius for highlighting. - - -### BUG FIXES - - * DT[,5] now returns 5 as FAQ 1.1 says, for consistency - with DT[,c(5)] and DT[,5+0]. DT[,""region""] now returns - ""region"" as FAQ 1.2 says. Thanks to Harish V for reporting. - - * When a quote()-ed expression q is passed to 'by' using - by=eval(q), the group column names now come from the list - in the expression rather than the name 'q' (bug #974) and, - multiple items work (bug #975). Thanks to Harish V for - reporting. - - * quote()-ed i and j expressions receive similar fixes, bugs - #977 and #1058. Thanks to Harish V and Branson Owen for - reporting. - - * Multiple errors (grammar, format and spelling) in intro.Rnw - and faqs.Rnw corrected by Dennis Murphy. Thank you. - - * Memory is now reallocated in rare cases when the up front - allocate for the result of grouping is insufficient. Bug - #952 raised by Georg V, and also reported by Harish. Thank - you. - - * A function call foo(arg=sum(b)) now finds b in DT when foo - contains DT[,eval(substitute(arg)),by=a], fixing bug #1026. - Thanks to Harish V for reporting. - - * If DT contains column 'a' then DT[J(unique(a))] now finds - 'a', fixing bug #1005. Thanks to Branson Owen for reporting. - - * 'by' on no data (for example when 'i' returns no rows) now - works, fixing bug #709. - - * 'by without by' now heeds nomatch=NA, fixing bug #1015. - Thanks to Harish V for reporting. - - * DT[NA] now returns 1 row of NA rather than the whole table - via standard NA logical recycling. A single NA logical is - a special case and is now replaced by NA_integer_. Thanks - to Branson Owen for highlighting the issue. - - * NROW removed from data.table, since the is.data.frame() in - base::NROW now returns TRUE due to inheritance. Fixes bug - #1039 reported by Bradley Buchsbaum. Thank you. - - * setkey() now coerces character to factor and double to - integer (provided they are all.equal), fixing bug #953. - Thanks to Steve Lianoglou for reporting. - - * 'by' now accepts lists from the calling scope without the - work around of wrapping with as.list() or {}, fixing bug - #1060. Thanks to Johann Hibschman for reporting. - - -### NOTES - - * The package uses the 'default' option of base::getOption, - and is therefore dependent on R 2.10.0. Updated DESCRIPTION - file accordingly. Thanks to Christian Hudon for reporting. - - -## data.table v1.4.1 - - -### NEW FEATURES - - * Vignettes tidied up. - - -### BUG FIXES - - * Out of order levels in key columns are now sorted by - setkey. Thanks to Steve Lianoglou for reporting. - - -## data.table v1.4 - - -### NEW FEATURES - - * 'by' faster. Memory is allocated first for the result, then - populated directly by the result of j for each group. Can be 10 - or more times faster than tapply() and aggregate(), see - timings vignette. - - * j should now be a list(), not DT(), of expressions. Use of - j=DT(...) is caught internally and replaced with j=list(...). - ---- - -7. Added some clarification about the usage of `on` to `?data.table`, [#2383](https://github.com/Rdatatable/data.table/issues/2383). Thanks to @peterlittlejohn for volunteering his confusion and @MichaelChirico for brushing things up. - -8. Clarified that ""data.table always sorts in `C-locale`"" means that upper-case letters are sorted before lower-case letters by ordering in data.table (e.g. `setorder`, `setkey`, `DT[order(...)]`). Thanks to @hughparsonage for the pull request editing the documentation. Note this makes no difference in most cases of data; e.g. ids where only uppercase or lowercase letters are used (`""AB123""<""AC234""` is always true, regardless), or country names and words which are consistently capitalized. For example, `""America"" < ""Brazil""` is not affected (it's always true), and neither is `""america"" < ""brazil""` (always true too); since the first letter is consistently capitalized. But, whether `""america"" < ""Brazil""` (the words are not consistently capitalized) is true or false in base R depends on the locale of your R session. In America it is true by default and false if you i) type `Sys.setlocale(locale=""C"")`, ii) the R session has been started in a C locale for you which can happen on servers/services (the locale comes from the environment the R session is started in). However, `""america"" < ""Brazil""` is always, consistently false in data.table which can be a surprise because it differs to base R by default in most regions. It is false because `""B""<""a""` is true because all upper-case letters come first, followed by all lower case letters (the ascii number of each letter determines the order, which is what is meant by `C-locale`). - -9. `data.table`'s dependency has been moved forward from R 3.0.0 (Apr 2013) to R 3.1.0 (Apr 2014; i.e. 3.5 years old). We keep this dependency as old as possible for as long as possible as requested by users in managed environments. Thanks to Jan Gorecki, the test suite from latest dev now runs on R 3.1.0 continuously, as well as R-release (currently 3.4.2) and latest R-devel snapshot. The primary motivation for the bump to R 3.1.0 was allowing one new test which relies on better non-copying behaviour in that version, [#2484](https://github.com/Rdatatable/data.table/issues/2484). It also allows further internal simplifications. Thanks to @MichaelChirico for fixing another test that failed on R 3.1.0 due to slightly different behaviour of `base::read.csv` in R 3.1.0-only which the test was comparing to, [#2489](https://github.com/Rdatatable/data.table/pull/2489). - -10. New vignette added: _Importing data.table_ - focused on using data.table as a dependency in R packages. Answers most commonly asked questions and promote good practices. - -11. As warned in v1.9.8 release notes below in this file (25 Nov 2016) it has been 1 year since then and so use of `options(datatable.old.unique.by.key=TRUE)` to restore the old default is now deprecated with warning. The new warning states that this option still works and repeats the request to pass `by=key(DT)` explicitly to `unique()`, `duplicated()`, `uniqueN()` and `anyDuplicated()` and to stop using this option. In another year, this warning will become error. Another year after that the option will be removed. - -12. As `set2key()` and `key2()` have been warning since v1.9.8 (Nov 2016), their warnings have now been upgraded to errors. Note that when they were introduced in version 1.9.4 (Oct 2014) they were marked as 'experimental' in NEWS item 4. They will be removed in one year. - - ``` - Was warning: set2key() will be deprecated in the next release. Please use setindex() instead. - Now error: set2key() is now deprecated. Please use setindex() instead. - ``` - ---- - -back to data.table after a long time with dplyr #rstats - -25 Dec 2014 Hadley Wickham on Hacker News - -Data tables are extremely fast but I think their concision makes it harder to learn and code that uses it is harder to read after you've written it. It's very reminiscent of APL. - -Our response: See the hacker news item and comparing dplyr to data.table on Stack Overflow. The word reminiscent was used to convey the notion of-the-past and is meant as criticism. Note that Hadley was responding to a positive post about data.table on Hacker News. The original item was : - -Anyone doing R comparisons should use data.table instead of data.frame. More so for benchmarks. data.table is the best data structure/query language I have found in my career. It's leading the way in The R world, and in my way, in all the data-focused languages. - -Hadley sought to shoot down this positive sentiment. His negative sentiment is what has stuck in the community rather than the original post which was positive. That's what works. - -26 Jun 2014 Hadley Wickham on Stack Overflow - -Also read.csv() reads everything into a big character matrix and then modifies that, does fread() do the same thing? In fastread we guess column types and then coerce as we go to avoid a complete copy of the df. - -The Stack Overflow question is ""Reason behind speed of fread in data.table package in R"" and an implicit compliment to data.table. That's the context. The comment is a subtle way to i) create doubt about fread and ii) announce his new fastread package which had not been known before that. fastread subsequently became readr. - ---- - -#include ""data.table.h"" - -/* -Implements binary search (a.k.a. divide and conquer). -http://en.wikipedia.org/wiki/Binary_search -http://www.tbray.org/ongoing/When/200x/2003/03/22/Binary -http://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html -Differences over standard binary search (e.g. bsearch in stdlib.h) : - o list of vectors (key of many columns) of different types - o ties (groups) - o NA,NAN,-Inf,+Inf are distinct values and can be joined to - o type double is joined within tolerance (apx 11 s.f.) according to setNumericRounding (default off) - o join to prevailing value (roll join a.k.a locf), forwards or backwards - o join to nearest - o roll the beginning and end optionally - o limit the roll distance to a user provided value - o non equi joins (no != yet) since 1.9.8 -*/ - -#define EQ 1 -#define LE 2 -#define LT 3 -#define GE 4 -#define GT 5 - -static const SEXP *idtVec, *xdtVec; -static const int *icols, *xcols; -static SEXP nqgrp; -static int ncol, *o, *xo, *retFirst, *retLength, *retIndex, *allLen1, *allGrp1, *rollends, ilen, anslen; -static int *op, nqmaxgrp; -static int ctr, nomatch; // populating matches for non-equi joins -enum {ALL, FIRST, LAST, ERR} mult = ALL; -static double roll, rollabs; -static Rboolean rollToNearest=FALSE; -#define XIND(i) (xo ? xo[(i)]-1 : i) - -void bmerge_r(int xlowIn, int xuppIn, int ilowIn, int iuppIn, int col, int thisgrp, int lowmax, int uppmax); - -SEXP bmerge(SEXP idt, SEXP xdt, SEXP icolsArg, SEXP xcolsArg, SEXP xoArg, SEXP rollarg, SEXP rollendsArg, SEXP nomatchArg, SEXP multArg, SEXP opArg, SEXP nqgrpArg, SEXP nqmaxgrpArg) { - const bool verbose = GetVerbose(); - double tic=0.0, tic0=0.0; - if (verbose) - tic = omp_get_wtime(); - int xN, iN, protecti=0; - ctr=0; // needed for non-equi join case - SEXP retFirstArg, retLengthArg, retIndexArg, allLen1Arg, allGrp1Arg; - retFirstArg = retLengthArg = retIndexArg = R_NilValue; // suppress gcc msg - ---- - -See \href{../doc/datatable-intro.html}{\code{vignette(""datatable-intro"")}} and \code{example(data.table)}.} - - \item{by}{ Column names are seen as if they are variables (as in \code{j} when \code{with=TRUE}). The \code{data.table} is then grouped by the \code{by} and \code{j} is evaluated within each group. The order of the rows within each group is preserved, as is the order of the groups. \code{by} accepts: - - \itemize{ - \item A single unquoted column name: e.g., \code{DT[, .(sa=sum(a)), by=x]} - - \item a \code{list()} of expressions of column names: e.g., \code{DT[, .(sa=sum(a)), by=.(x=x>0, y)]} - - \item a single character string containing comma separated column names (where spaces are significant since column names may contain spaces even at the start or end): e.g., \code{DT[, sum(a), by=""x,y,z""]} - - \item a character vector of column names: e.g., \code{DT[, sum(a), by=c(""x"", ""y"")]} - - \item or of the form \code{startcol:endcol}: e.g., \code{DT[, sum(a), by=x:z]} - } - - \emph{Advanced:} When \code{i} is a \code{list} (or \code{data.frame} or \code{data.table}), \code{DT[i, j, by=.EACHI]} evaluates \code{j} for the groups in \code{DT} that each row in \code{i} joins to. That is, you can join (in \code{i}) and aggregate (in \code{j}) simultaneously. We call this \emph{grouping by each i}. See \href{https://stackoverflow.com/a/27004566/559784}{this StackOverflow answer} for a more detailed explanation until we \href{https://github.com/Rdatatable/data.table/issues/944}{roll out vignettes}. - - \emph{Advanced:} In the \code{X[Y, j]} form of grouping, the \code{j} expression sees variables in \code{X} first, then \code{Y}. We call this \emph{join inherited scope}. If the variable is not in \code{X} or \code{Y} then the calling frame is searched, its calling frame, and so on in the usual way up to and including the global environment.} - - \item{keyby}{ Same as \code{by}, but with an additional \code{setkey()} run on the \code{by} columns of the result, for convenience. It is common practice to use \code{keyby=} routinely when you wish the result to be sorted. May also be \code{TRUE} or \code{FALSE} when \code{by} is provided as an alternative way to accomplish the same operation.} - - \item{with}{ By default \code{with=TRUE} and \code{j} is evaluated within the frame of \code{x}; column names can be used as variables. In the case of overlapping variable names inside \code{x} and in parent scope, you can use the double dot prefix \code{..cols} to explicitly refer to the \code{cols} variable in parent scope and not from \code{x}. - - When \code{j} is a character vector of column names, a numeric vector of column positions to select, or of the form \code{startcol:endcol}, the value returned is always a \code{data.table}. - - New code should rarely use this argument, which was originally needed for similarity to data.frame. For example, to select columns from a character vector \code{cols}, in data.frame we do \code{x[, cols]}, which has several equivalents in data.table: \code{x[, .SD, .SDcols=cols]}, \code{x[, ..cols]}, \code{x[, cols, env = list(cols = I(cols))]}, or \code{x[, cols, with=FALSE]}.} - - \item{nomatch}{ When a row in \code{i} has no match to \code{x}, \code{nomatch=NA} (default) means \code{NA} is returned. \code{NULL} (or \code{0} for backward compatibility) means no rows will be returned for that row of \code{i}. } - - \item{mult}{ When \code{i} is a \code{list} (or \code{data.frame} or \code{data.table}) and \emph{multiple} rows in \code{x} match to the row in \code{i}, \code{mult} controls which are returned: \code{""all""} (default), \code{""first""} or \code{""last""}.} - - \item{roll}{ When \code{i} is a \code{data.table} and its row matches to all but the last \code{x} join column, and its value in the last \code{i} join column falls in a gap (including after the last observation in \code{x} for that group), then: - ---- - -6. Using a double vector in `set()`'s `i=` and/or `j=` no longer throws a warning about preferring integer, [#6594](https://github.com/Rdatatable/data.table/issues/6594). While it may improve efficiency to use integer, there's no guarantee it's an improvement and the difference is likely to be minimal. The coercion will still be reported under `datatable.verbose=TRUE`. For package/production use cases, static analyzers such as `lintr::implicit_integer_linter()` can also report when numeric literals should be rewritten as integer literals. - -7. In rare situations a data.table object may lose its internal attribute that holds a self-reference. New helper function `.selfref.ok()` tests just that. It is only intended for technical use cases. See manual for examples. - -8. Retain important information in the error message about the source of the error when `i=` fails, e.g. pointing to `charToDate()` failing in `DT[date_col == ""20250101""]`, [#7444](https://github.com/Rdatatable/data.table/issues/7444). Thanks @jan-swissre for the report and @MichaelChirico for the fix. - -9. Internal use of declared non-API R functions `SETLENGTH`, `TRUELENGTH`, `SET_TRUELENGTH`, and `SET_GROWABLE_BIT` has been eliminated. Most usages have been migrated to R's experimental resizable vectors API (thanks to @ltierney, introduced in R 4.6.0, backported for older R versions), [#7451](https://github.com/Rdatatable/data.table/pull/7451). Uses of `TRUELENGTH` for marking seen items during grouping and binding operations (aka free hash table trick) have been replaced with proper hash tables, [#6694](https://github.com/Rdatatable/data.table/pull/6694). The new hash table implementation uses linear probing with power of 2 tables and automatic resizing. Additionally, `chmatch()` now hashes the needle (`x`) instead of the haystack (`table`) when `length(table) >> length(x)`, significantly improving performance for lookups into large tables. We've benchmarked the refactored code and find the performance satisfactory, but please do report any edge case performance regressions we may have missed. Thanks to @aitap, @ben-schwen, @jangorecki and @HughParsonage for implementation and reviews. - -## data.table [v1.17.8](https://github.com/Rdatatable/data.table/milestone/41) (6 July 2025) - -1. Internal functions used to signal errors are now marked as non-returning, silencing a compiler warning about potentially unchecked allocation failure. Thanks to Prof. Brian D. Ripley for the report and @aitap for the fix, [#7070](https://github.com/Rdatatable/data.table/pull/7070). - -## data.table [v1.17.6](https://github.com/Rdatatable/data.table/milestone/40) (15 June 2025) - -1. On a heavily loaded machine, a `forder` thread could try to perform a zero-length copy from a null pointer, which was de-facto harmless but is against the C standard and was caught by additional CRAN checks, [#7051](https://github.com/Rdatatable/data.table/issues/7051). Thanks to @helske for the report and @aitap for the PR. - -## data.table [v1.17.4](https://github.com/Rdatatable/data.table/milestone/39) (25 May 2025) - -1. The C code now avoids passing invalid data pointers from 0-length vectors to `memcpy()`, which previously caused undefined behaviour. Thanks to Prof. Brian D. Ripley for the report and Michael Chirico for the fix, [#6911](https://github.com/Rdatatable/data.table/pull/6911). - -## data.table [v1.17.2](https://github.com/Rdatatable/data.table/milestone/38) (7 May 2025) - -### BUG FIXES - -1. `fwrite(compress=""gzip"")` once again produces a gzip header when the column names are missing or disabled, [@6852](https://github.com/Rdatatable/data.table/issues/6852). Thanks @maxscheiber for the report and @aitap for the fix. - -2. `fread(keepLeadingZeros=TRUE)` now correctly parses dates with components with leading zeros as dates instead of strings, [#6851](https://github.com/Rdatatable/data.table/issues/6851). Thanks @TurnaevEvgeny for the report and @ben-schwen for the fix. - ---- - -#: assign.c:453 -#, c-format -msgid """" -""truelength (%d) is greater than 10,000 items over-allocated (length = %d). "" -""See ?truelength. If you didn't set the datatable.alloccol option very large, "" -""please report to data.table issue tracker including the result of "" -""sessionInfo()."" -msgstr """" -""truelength (%d) est supérieur à 10 000 éléments sur-alloués (length = %d). "" -""Voir ?truelength. Si vous n'avez pas mis une très grande valeur à l'option "" -""datatable.alloccol, veuillez rapporter ce problème dans le gestionnaire de "" -""tickets (issue tracker) de data.table en incluant le résultat de "" -""sessionInfo()."" - -#: assign.c:457 -msgid """" -""It appears that at some earlier point, names of this data.table have been "" -""reassigned. Please ensure to use setnames() rather than names<- or "" -""colnames<-. Otherwise, please report to data.table issue tracker."" -msgstr """" -""Il semble qu'à un moment donné, les noms de cette table data.table aient été "" -""réattribués. Veillez à utiliser setnames() plutôt que names<- ou colnames<-. "" -""Dans le cas contraire, signalez le problème dans le gestionnaire de tickets "" -""(issue tracker) de data.table."" - -#: assign.c:464 -msgid """" -""It appears that at some earlier point, attributes of this data.table have "" -""been reassigned. Please use setattr(DT, name, value) rather than attr(DT, "" -""name) <- value. If that doesn't apply to you, please report your case to the "" -""data.table issue tracker."" -msgstr """" -""Il semble qu'à un moment donné, les attributs de ce data.table aient été "" -""réattribués. Veillez à utiliser setattr(DT, nom, valeur) plutôt que attr(DT, "" -""nom) <- valeur. Si cela ne vous concerne pas, veuillez signaler le problème "" -""dans le gestionnaire de tickets (issue tracker) de data.table."" - -#: assign.c:496 -#, c-format -msgid """" -""RHS for item %d has been duplicated because MAYBE_REFERENCED==%d "" -""MAYBE_SHARED==%d ALTREP==%d, but then is being plonked. length(values)==%d; "" -""length(cols)==%d\n"" -msgstr """" -""Le membre droit (RHS) pour l'élément %d a été dupliqué parce que "" -""MAYBE_REFERENCED==%d MAYBE_SHARED==%d ALTREP==%d, mais il est ensuite "" -""remplacé ('plonk'). length(values)==%d ; length(cols)==%d\n"" - -#: assign.c:501 -#, c-format -msgid """" -""Direct plonk of unnamed RHS, no copy. MAYBE_REFERENCED==%d, MAYBE_SHARED=="" -""%d\n"" -msgstr """" -""Remplacement ('plonk') du membre de droite (RHS) sans nom, pas de copie. "" -""MAYBE_REFERENCED==%d, MAYBE_SHARED==%d\n"" - -#: assign.c:570 -#, c-format -msgid """" -""Dropping index '%s' as it doesn't have '__' at the beginning of its name. It "" -""was very likely created by v1.9.4 of data.table.\n"" -msgstr """" -""Suppression de l'indice '%s' car il n'a pas '__' au début de son nom. Il a "" -""très probablement été créé par la version 1.9.4 de data.table.\n"" - -#: assign.c:615 assign.c:631 -#, c-format -msgid ""Dropping index '%s' due to an update on a key column\n"" -msgstr """" -""Suppression de l'indice '%s' suite à une mise à jour d'une colonne clé\n"" - -#: assign.c:624 -#, c-format -msgid ""Shortening index '%s' to '%s' due to an update on a key column\n"" -msgstr """" -""Raccourcissement de l'indice '%s' en '%s' suite à une mise à jour d'une "" -""colonne clé\n"" - -#: assign.c:682 -#, c-format -msgid ""(column %d named '%s')"" -msgstr ""(colonne %d nommée '%s')"" - -#: assign.c:716 -#, c-format -msgid """" -""Cannot assign 'factor' to '%s'. Factors can only be assigned to factor, "" -""character or list columns."" -msgstr """" -""Impossible d'affecter 'factor' à '%s'. Les facteurs ne peuvent être affectés "" -""qu'à des colonnes de facteurs, de caractères ou de listes."" - -#: assign.c:731 -#, c-format -#| msgid """" -#| ""Assigning factor numbers to %s. But %d is outside the level range [1,%d]"" -msgid """" -""Assigning factor numbers to target vector. But %d is outside the level range "" -""[1,%d]"" -msgstr """" -""Attribution des numéros de facteurs au vecteur cible. Mais %d est en dehors "" -""de l'intervalle des niveaux [1,%d]"" - ---- - -R data.table FAQ vignette has been converted to Rmarkdown format and can be found here. It is also shipped together with data.table package, so it can be accessed locally using vignette(""datatable-faq"", package=""data.table""). - ---- - -foverlaps = function(x, y, by.x=key(x) %||% key(y), by.y=key(y), maxgap=0L, minoverlap=1L, type=c(""any"", ""within"", ""start"", ""end"", ""equal""), mult=c(""all"", ""first"", ""last""), nomatch=NA, which=FALSE, verbose=getOption(""datatable.verbose"")) { - - if (!is.data.table(y) || !is.data.table(x)) stopf(""y and x must both be data.tables. Use `setDT()` to convert list/data.frames to data.tables by reference or as.data.table() to convert to data.tables by copying."") - maxgap = as.integer(maxgap); minoverlap = as.integer(minoverlap) - which = as.logical(which) - .unsafe.opt() #3585 - nomatch = if (is.null(nomatch)) 0L else as.integer(nomatch) - if (!length(maxgap) || length(maxgap) != 1L || is.na(maxgap) || maxgap < 0L) - stopf(""maxgap must be a non-negative integer value of length 1"") - if (!length(minoverlap) || length(minoverlap) != 1L || is.na(minoverlap) || minoverlap < 1L) - stopf(""minoverlap must be a positive integer value of length 1"") - if (!isTRUEorFALSE(which)) - stopf(""'%s' must be TRUE or FALSE"", ""which"") - if (!length(nomatch) || length(nomatch) != 1L || (!is.na(nomatch) && nomatch!=0L)) - stopf(""nomatch must either be NA or NULL"") - type = match.arg(type) - mult = match.arg(mult) - # if (maxgap > 0L || minoverlap > 1L) # for future implementation - if (maxgap != 0L || minoverlap != 1L) - stopf(""maxgap and minoverlap arguments are not yet implemented."") - if (is.null(by.y)) - stopf(""y must be keyed (i.e., sorted, and, marked as sorted). Call setkey(y, ...) first, see ?setkey. Also check the examples in ?foverlaps."") - if (length(by.x) < 2L || length(by.y) < 2L) - stopf(""'by.x' and 'by.y' should contain at least two column names (or numbers) each - corresponding to 'start' and 'end' points of intervals. Please see ?foverlaps and examples for more info."") - if (is.numeric(by.x)) { - if (any(by.x < 0L) || any(by.x > length(x))) - stopf(""Invalid numeric value for 'by.x'; it should be a vector with values 1 <= by.x <= length(x)"") - by.x = names(x)[by.x] - } - if (is.numeric(by.y)) { - if (any(by.y < 0L) || any(by.y > length(y))) - stopf(""Invalid numeric value for 'by.y'; it should be a vector with values 1 <= by.y <= length(y)"") - by.y = names(y)[by.y] - } - if (!is.character(by.x)) - stopf(""A non-empty vector of column names or numbers is required for '%s'"", ""by.x"") - if (!is.character(by.y)) - stopf(""A non-empty vector of column names or numbers is required for '%s'"", ""by.y"") - if (!identical(by.y, key(y)[seq_along(by.y)])) - stopf(""The first %d columns of y's key must be identical to the columns specified in by.y."", length(by.y)) - if (anyNA(chmatch(by.x, names(x)))) - stopf(""Elements listed in 'by.x' must be valid names in data.table x"") - if (anyDuplicated(by.x) || anyDuplicated(by.y)) - stopf(""Duplicate columns are not allowed in overlap joins. This may change in the future."") - if (length(by.x) != length(by.y)) - stopf(""length(by.x) != length(by.y). Columns specified in by.x should correspond to columns specified in by.y and should be of same lengths."") - - #1730 - handling join possible but would require workarounds on setcolorder further, it is really better just to rename dup column - check_duplicate_names(x) - check_duplicate_names(y) - ---- - -* gains argument `strip.white` which is `TRUE` by default (unlike `base::read.table`). All unquoted columns' leading and trailing white spaces are automatically removed. If \code{FALSE}, only trailing spaces of header is removed. Closes [#1113](https://github.com/Rdatatable/data.table/issues/1113), [#1035](https://github.com/Rdatatable/data.table/issues/1035), [#1000](https://github.com/Rdatatable/data.table/issues/1000), [#785](https://github.com/Rdatatable/data.table/issues/785), [#529](https://github.com/Rdatatable/data.table/issues/529) and [#956](https://github.com/Rdatatable/data.table/issues/956). Thanks to @dmenne, @dpastoor, @GHarmata, @gkalnytskyi, @renqian, @MatthewForrest, @fxi and @heraldb. - * doesn't warn about empty lines when 'nrow' argument is specified and that many rows are read properly. Thanks to @richierocks for the report. Closes [#1330](https://github.com/Rdatatable/data.table/issues/1330). - * doesn't error/warn about not being able to read last 5 lines when 'nrow' argument is specified. Thanks to @robbig2871. Closes [#773](https://github.com/Rdatatable/data.table/issues/773). - ---- - -También puede usar solo un subconjunto de las funciones de `data.table`; por ejemplo, algunos paquetes pueden usar simplemente el lector y escritor de CSV de alto rendimiento de `data.table`, para lo cual puede agregar `importFrom(data.table, fread, fwrite)` en su archivo `NAMESPACE`. También es posible importar todas las funciones de un paquete, *excluyendo* algunas específicas, usando `import(data.table, except=c(fread, fwrite))`. - -Asegúrese de leer también la nota sobre la evaluación no estándar en `data.table` en [la sección sobre ""globales indefinidos""](#globals). - -## Uso - -Como ejemplo, definiremos dos funciones en el paquete `a.pkg` que utilizan `data.table`. Una función, `gen`, generará un `data.table` simple; otra, `aggr`, realizará una agregación simple del mismo. - -```r -gen = function (n = 100L) { - dt = as.data.table(list(id = seq_len(n))) - dt[, grp := ((id - 1) %% 26) + 1 - ][, grp := letters[grp] - ][] -} -aggr = function (x) { - stopifnot( - is.data.table(x), - ""grp"" %in% names(x) - ) - x[, .N, by = grp] -} -``` - -## Pruebas - -Asegúrese de incluir pruebas en su paquete. Antes de cada lanzamiento principal de `data.table`, verificamos las dependencias inversas. Esto significa que si algún cambio en `data.table` pudiera afectar su código, podremos detectar los cambios problemáticos e informarle antes de publicar la nueva versión. Esto, por supuesto, supone que publicará su paquete en CRAN o Bioconductor. La prueba más básica puede ser un script de R en texto plano en el directorio `tests/test.R` de su paquete: - -```r -library(a.pkg) -dt = gen() -stopifnot(nrow(dt) == 100) -dt2 = aggr(dt) -stopifnot(nrow(dt2) < 100) -``` - -Al probar su paquete, puede utilizar `R CMD check --no-stop-on-test-error`, que continuará después de un error y ejecutará todas sus pruebas (en lugar de detenerse en la primera línea del script que falló). - -## Pruebas usando `testthat` - -Es muy común usar el paquete `testthat` para realizar pruebas. Probar un paquete que importa `data.table` no es diferente a probar otros paquetes. Un ejemplo de script de prueba `tests/testthat/test-pkg.R`: - -```r -context(""pkg tests"") - -test_that(""generate dt"", { expect_true(nrow(gen()) == 100) }) -test_that(""aggregate dt"", { expect_true(nrow(aggr(gen())) < 100) }) -``` - -Si `data.table` está en ""Suggests"" (pero no en ""Imports""), entonces necesita declarar `.datatable.aware=TRUE` en uno de los archivos R/* para evitar errores de ""objeto no encontrado"" al realizar pruebas a través de `testthat::test_package` o `testthat::test_check`. - -## Cómo lidiar con ""undefined global functions or variables "" {#globals} - -El uso de la evaluación diferida de R por parte de `data.table` (especialmente en el lado izquierdo de `:=`) no es bien reconocido por `R CMD check`. Esto genera `NOTE`s como la siguiente durante la comprobación del paquete: - -``` -* checking R code for possible problems ... NOTE -aggr: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'grp' -gen: no visible binding for global variable 'id' -Undefined global functions or variables: -grp id -``` - -La forma más sencilla de solucionar esto es predefinir esas variables dentro del paquete y establecerlas como `NULL`, añadiendo opcionalmente un comentario (como se hace en la versión refinada de `gen` a continuación). Siempre que sea posible, también puede usar un vector de caracteres en lugar de símbolos (como en `aggr` a continuación): - -```r -gen = function (n = 100L) { - id = grp = NULL # due to NSE notes in R CMD check - dt = as.data.table(list(id = seq_len(n))) - dt[, grp := ((id - 1) %% 26) + 1 - ][, grp := letters[grp] - ][] -} -aggr = function (x) { - stopifnot( - is.data.table(x), - ""grp"" %in% names(x) - ) - x[, .N, by = ""grp""] -} -``` - ---- - -Una versión futura de data.table podría permitir distinguir entre una clave y una *clave única*. Internamente, `mult = ""all""` funcionaría de forma similar a `mult = ""first""` cuando todas las columnas de la clave de `x` estuvieran unidas y la clave de `x` fuera única. data.table necesitaría comprobaciones al insertar y actualizar para garantizar que se mantenga una clave única. Una ventaja de especificar una clave única sería que, además de mejorar el rendimiento, data.table garantizaría que no se insertaran duplicados. - -## Estoy usando `c()` en `j` y obtengo resultados extraños. - -Esta es una fuente común de confusión. En `data.frame` se suele usar, por ejemplo: - -```{r} -DF = data.frame(x = 1:3, y = 4:6, z = 7:9) -DF -DF[ , c(""y"", ""z"")] -``` - -Que devuelve las dos columnas. En data.table, sabe que puede usar los nombres de las columnas directamente y podría intentar: - -```{r} -DT = data.table(DF) -DT[ , c(y, z)] -``` - -Pero esto devuelve un vector. Recuerde que la expresión `j` se evalúa en el entorno de `DT` y `c()` devuelve un vector. Si se requieren dos o más columnas, utilice `list()` o `.()` en su lugar: - -```{r} -DT[ , .(y, z)] -``` - -`c()` también puede ser útil en una data.table, pero su comportamiento es diferente al de `[.data.frame`. - -## He creado una tabla compleja con muchas columnas. Quiero usarla como plantilla para una nueva tabla; es decir, crear una tabla sin filas, pero con los nombres y tipos de columna copiados de mi tabla. ¿Es fácil hacerlo? - -Sí. Si su tabla compleja se llama `DT`, intente `NEWDT = DT[0]`. - -## ¿Es un data.table nulo lo mismo que `DT[0]`? - -No. Por ""data.table nulo"" nos referimos al resultado de `data.table(NULL)` o `as.data.table(NULL)`; *es decir*, - -```{r} -data.table(NULL) -data.frame(NULL) -as.data.table(NULL) -as.data.frame(NULL) -is.null(data.table(NULL)) -is.null(data.frame(NULL)) -``` - -El objeto data.table|`frame` nulo es `NULL` con algunos atributos adjuntos, lo que significa que ya no es `NULL`. En R, solo `NULL` puro es `NULL`, como se prueba con `is.null()`. Al referirnos al objeto ""data.table"" nulo, usamos `null` en minúscula para distinguirlo de `NULL` en mayúscula. Para comprobar si el objeto data.table es nulo, use `length(DT) == 0` o `ncol(DT) == 0` (`length` es ligeramente más rápido, ya que es una función primitiva). - -Una data.table *vacía* (`DT[0]`) tiene una o más columnas, todas ellas vacías. Estas columnas vacías aún conservan nombres y tipos. - -```{r} -DT = data.table(a = 1:3, b = c(4, 5, 6), d = c(7L,8L,9L)) -DT[0] -sapply(DT[0], class) -``` - -## ¿Por qué se ha eliminado el alias `DT()`? {#DTremove1} - -`DT` se introdujo originalmente como contenedor para una lista de expresiones `j`. Dado que `DT` era un alias de data.table, era una forma práctica de gestionar el reciclaje silencioso en casos en que cada elemento de la lista `j` evaluaba con longitudes diferentes. Sin embargo, el alias era una de las razones por las que la agrupación era lenta. - -A partir de la v1.3, se deben pasar `list()` o `.()` al argumento `j`. Esto es mucho más rápido, especialmente cuando hay muchos grupos. Internamente, este cambio no fue trivial. El reciclaje de vectores ahora se realiza internamente, junto con otras mejoras de velocidad para la agrupación. - -## Pero mi código usa `j = DT(...)` y funciona. Las preguntas frecuentes anteriores indican que se ha eliminado `DT()`. {#DTremove2} - -Entonces estás usando una versión anterior a la 1.5.3. Antes de la 1.5.3, `[.data.table` detectaba el uso de `DT()` en `j` y lo reemplazaba automáticamente con una llamada a `list()`. Esto facilitaba la transición para los usuarios existentes. - -## ¿Cuáles son las reglas de alcance para las expresiones 'j'? - -Piense en el subconjunto como un entorno donde todos los nombres de columna son variables. Cuando se utiliza la variable `foo` en la `j` de una consulta como `X[Y, sum(foo)]`, se busca `foo` en el siguiente orden: - ---- - -Ahora funciona la sintaxis más natural: - -```{r} -if (packageVersion(""data.table"") >= ""1.8.1"") { - DT[ , .N, by = list(a, b)][ , unique(N), by = a] - } -if (packageVersion(""data.table"") >= ""1.9.3"") { - DT[ , .N, by = .(a, b)][ , unique(N), by = a] # same -} -``` - -# Mensajes de advertencia - -## ""Los siguientes objetos están enmascarados de `paquete:base`: `cbind`, `rbind`"" - -Esta advertencia solo aparecía en las versiones 1.6.5 y 1.6.6 al cargar el paquete. El objetivo era permitir que `cbind(DT, DF)` funcionara, pero resultó que esto interrumpía la compatibilidad total con el paquete `IRanges`. Actualice a la versión 1.6.7 o posterior. - -## ""Se convirtió el RHS numérico a entero para que coincida con el tipo de la columna"" - -Espero que esto se explique por sí solo. El mensaje completo es: - -Se ha convertido el RHS numérico a entero para que coincida con el tipo de la columna; puede tener precisión truncada. Cambie la columna a numérica primero creando un nuevo vector numérico de longitud 5 (n filas de toda la tabla) y asignándolo (es decir, ""reemplazar columna""), o convierta el RHS a entero (por ejemplo, 1L o as.integer) para aclarar su intención (y para mayor rapidez). O bien, configure el tipo de columna correctamente desde el principio al crear la tabla y manténgalo. - -Para generarlo, prueba: - -```{r} -DT = data.table(a = 1:5, b = 1:5) -suppressWarnings( -DT[2, b := 6] # works (slower) with warning -) -class(6) # numeric not integer -DT[2, b := 7L] # works (faster) without warning -class(7L) # L makes it an integer -DT[ , b := rnorm(5)] # 'replace' integer column with a numeric column -``` - -## Lectura de data.table desde un archivo RDS o RData - -`*.RDS` y `*.RData` son tipos de archivo que permiten almacenar objetos R en memoria en disco de forma eficiente. Sin embargo, al almacenar `data.table` en un archivo binario, se pierde la sobreasignación de columnas (véase también `?truelength`). Esto no supone un gran problema: su `data.table` se copiará en memoria en la siguiente operación *por referencia* y generará una advertencia. Por lo tanto, se recomienda ejecutar `setDT()` en cada `data.table` cargado con `readRDS()` o `load()` para restaurar sus atributos internos. Si solo necesita preasignar espacio para nuevas columnas, también puede usar `setalloccol()`. - -Para obtener más detalles, consulte `?setDT` y `?truelength`. - -# Preguntas generales sobre el paquete - -## ¿Parece que la versión v1.3 falta en el archivo CRAN? - -Así es. La versión 1.3 solo estaba disponible en R-Forge. Se implementaron varios cambios importantes internamente, y las pruebas en desarrollo llevaron tiempo. - -## ¿Es data.table compatible con S-plus? - -No actualmente. - - - Algunas partes principales del paquete están escritas en C y utilizan funciones y estructuras internas de R. - - El paquete utiliza alcance léxico, que es una de las diferencias entre R y **S-plus** explicadas en [R FAQ 3.3.1](https://cran.r-project.org/doc/FAQ/R-FAQ.html#Lexical-scoping) - -## ¿Está disponible para Linux, Mac y Windows? - -Sí, tanto para 32 bits como para 64 bits en todas las plataformas. Gracias a CRAN. No se utilizan bibliotecas especiales ni específicas del sistema operativo. - -## Me parece genial. ¿Qué puedo hacer? - -Envíe sugerencias, informes de errores y solicitudes de mejora a nuestro [seguimiento de problemas](https://github.com/Rdatatable/data.table/issues). Esto contribuye a mejorar el paquete. - -Por favor, marque el paquete con una estrella en [GitHub](https://github.com/Rdatatable/data.table). Esto anima a los desarrolladores y ayuda a otros usuarios de R a encontrarlo. - -Puede enviar solicitudes de extracción para cambiar el código y/o la documentación usted mismo; consulte nuestras [Pautas de contribución](https://github.com/Rdatatable/data.table/blob/master/.github/CONTRIBUTING.md). - -## No me parece bien. ¿Cómo puedo advertir a los demás sobre mi experiencia? - ---- - -#: data.table.R:139 -#, c-format -msgid ""Item '%s' not found in names of input list"" -msgstr ""Élément '%s' non trouvé parmi les noms de la liste d'entrée"" - -#: data.table.R:159 -#, c-format -msgid """" -""[ was called on a data.table in an environment that is not data.table-aware "" -""(i.e. cedta()), but '%s' was used, implying the owner of this call really "" -""intended for data.table methods to be called. See vignette('datatable-"" -""importing') for details on properly importing data.table."" -msgstr """" -""[ a été appelé sur un data.table dans un environnement qui n'est pas "" -""compatible avec data.table (i.e. cedta()), mais '%s' a été utilisé, ce qui "" -""implique que le propriétaire de cet appel avait vraiment l'intention "" -""d'appeler des méthodes data.table. Voir la vignette('datatable-importing') "" -""pour plus de détails sur l’importation correcte de data.table."" - -#: data.table.R:170 -#, c-format -msgid ""verbose must be logical or integer"" -msgstr ""verbose doit être soit un booléen, soit un entier"" - -#: data.table.R:171 -#, c-format -msgid ""verbose must be length 1 non-NA"" -msgstr ""verbose doit être de longueur 1 et différent de NA"" - -#: data.table.R:179 -#, c-format -msgid ""Ignoring by/keyby because 'j' is not supplied"" -msgstr ""L'argument by ou keyby est ignoré car 'j' n'est pas fourni"" - -#: data.table.R:193 -#, c-format -msgid ""When by and keyby are both provided, keyby must be TRUE or FALSE"" -msgstr """" -""Si by et keyby sont fournis simultanément, keyby doit être TRUE ou FALSE"" - -#: data.table.R:196 data.table.R:261 data.table.R:351 -msgid ""Argument '%s' after substitute: %s"" -msgstr ""Argument '%s' après substitution : %s"" - -#: data.table.R:205 -#, c-format -msgid """" -""When on= is provided but not i=, on= must be a named list or data.table|"" -""frame, and a natural join (i.e. join on common names) is invoked. Ignoring "" -""on= which is '%s'."" -msgstr """" -""Lorsque on= est fourni mais pas i=, on= doit être une liste nommée ou un "" -""data.table|frame, et une jointure naturelle (c'est-à-dire une jointure sur "" -""les noms communs) est invoquée. La valeur de on= qui est '%s' est ignorée."" - -#: data.table.R:218 -#, c-format -msgid """" -""i and j are both missing so ignoring the other arguments. This warning will "" -""be upgraded to error in future."" -msgstr """" -""i et j sont tous les deux absents, donc les autres arguments sont ignorés. "" -""Cet avertissement deviendra une erreur à l'avenir."" - -#: data.table.R:222 -#, c-format -msgid ""mult argument can only be 'first', 'last', 'all' or 'error'"" -msgstr ""l'argument mult ne peut valoir que 'first', 'last', 'all' ou 'error'"" - -#: data.table.R:224 -#, c-format -msgid """" -""roll must be a single TRUE, FALSE, positive/negative integer/double "" -""including +Inf and -Inf or 'nearest'"" -msgstr """" -""roll doit être une seule valeur TRUE, FALSE, un entier ou un double, positif "" -""ou négatif, +Inf, -Inf ou 'nearest' compris"" - -#: data.table.R:226 -#, c-format -msgid ""roll is '%s' (type character). Only valid character value is 'nearest'."" -msgstr """" -""roll vaut '%s' (de type caractère). La seule chaîne valide est 'nearest'."" - -#: data.table.R:231 -#, c-format -msgid ""rollends must be a logical vector"" -msgstr ""rollends doit être un vecteur de booléens"" - -#: data.table.R:232 -#, c-format -msgid ""rollends must be length 1 or 2"" -msgstr ""rollends doit être de longueur 1 ou 2"" - -#: data.table.R:240 -#, c-format -msgid """" -""nomatch= must be either NA or NULL (or 0 for backwards compatibility which "" -""is the same as NULL but please use NULL)"" -msgstr """" -""nomatch= doit valoir soit NA, soit NULL (ou 0 pour la compatibilité arrière "" -""qui équivaut à NULL, mais utiliser NULL dorénavant)"" - -#: data.table.R:243 -#, c-format -msgid ""which= must be a logical vector length 1. Either FALSE, TRUE or NA."" -msgstr """" -""which= doit être un vecteur de booléens de longueur 1. Valeur FALSE, TRUE ou "" -""NA."" - ---- - -Note also that you should consider these symbols read-only and of limited scope -- internal data.table code might manipulate them in unexpected ways, and as such their bindings are locked. There are subtle ways to wind up with the wrong object, especially when attempting to copy their values outside a grouping context. See examples; when in doubt, \code{copy()} is your friend. -} -\seealso{ - \code{\link{data.table}}, \code{\link{:=}}, \code{\link{set}}, \code{\link{datatable-optimize}} -} -\examples{ -DT = data.table(x=rep(c(""b"",""a"",""c""),each=3), v=c(1,1,1,2,2,1,1,2,2), y=c(1,3,6), a=1:9, b=9:1) -DT -X = data.table(x=c(""c"",""b""), v=8:7, foo=c(4,2)) -X - -DT[.N] # last row, only special symbol allowed in 'i' -DT[, .N] # total number of rows in DT -DT[, .N, by=x] # number of rows in each group -DT[, .SD, .SDcols=x:y] # select columns 'x' through 'y' -DT[, .SD[1]] # first row of all columns -DT[, .SD[1], by=x] # first row of all columns for each group in 'x' -DT[, c(.N, lapply(.SD, sum)), by=x] # get rows *and* sum all columns by group -DT[, .I[1], by=x] # row number in DT corresponding to each group -DT[, .N, by=rleid(v)] # get count of consecutive runs of 'v' -DT[, c(.(y=max(y)), lapply(.SD, min)), - by=rleid(v), .SDcols=v:b] # compute 'j' for each consecutive runs of 'v' -DT[, grp := .GRP, by=x] # add a group counter -DT[, grp_pct := .GRP/.NGRP, by=x] # add a group ""progress"" counter -X[, DT[.BY, y, on=""x""], by=x] # join within each group -DT[X, on=.NATURAL] # join X and DT on common column similar to X[on=Y] - -# .N can be different in i and j -DT[{cat(sprintf('in i, .N is \%d\n', .N)); a < .N/2}, - {cat(sprintf('in j, .N is \%d\n', .N)); mean(a)}] - -# .I can be different in j and by, enabling rowwise operations in by -DT[, .(.I, min(.SD[,-1]))] -DT[, .(min(.SD[,-1])), by=.I] - -# Do not expect this to correctly append the value of .BY in each group; copy(.BY) will work. -by_tracker = list() -DT[, { append(by_tracker, .BY); sum(v) }, by=x] -} -\keyword{ data } - ---- - -\code{IDateTime} takes a date-time input and returns a data table with -columns \code{date} and \code{time}. - -Using integer storage allows dates and/or times to be used as data table -keys. With positive integers with a range less than 100,000, grouping -and sorting is fast because radix sorting can be used (see -\code{sort.list}). - -Several convenience functions like \code{hour} and \code{quarter} are -provided to group or extract by hour, month, and other date-time -intervals. \code{as.POSIXlt} is also useful. For example, -\code{as.POSIXlt(x)$mon} is the integer month. The R base convenience -functions \code{weekdays}, \code{months}, and \code{quarters} can also -be used, but these return character values, so they must be converted to -factors for use with data.table. \code{isoweek} is ISO 8601-consistent. - -The \code{round} method for IDate's is useful for grouping and plotting. -It can round to weeks, months, quarters, and years. Similarly, the \code{round} -and \code{trunc} methods for ITime's are useful for grouping and plotting. -They can round or truncate to hours and minutes. -Note for ITime's with 30 seconds, rounding is inconsistent due to rounding off a 5. -See 'Details' in \code{\link{round}} for more information. - -Functions like \code{week()} and \code{isoweek()} provide week numbering functionality. -\code{week()} computes completed or fractional weeks within the year, -while \code{isoweek()} calculates week numbers according to ISO 8601 standards, -which specify that the first week of the year is the one containing the first Thursday. -This convention ensures that week boundaries align consistently with year boundaries, -accounting for both year transitions and varying day counts per week. - -Similarly, \code{isoyear()} returns the ISO 8601 year corresponding to the ISO week. - -} - -\value{ - For \code{as.IDate}, a class of \code{IDate} and \code{Date} with the - date stored as the number of days since some origin. - - For \code{as.ITime}, a class of \code{ITime} - stored as the number of seconds in the day. - - For \code{IDateTime}, a data table with columns \code{idate} and - \code{itime} in \code{IDate} and \code{ITime} format. - - \code{second}, \code{minute}, \code{hour}, \code{yday}, \code{wday}, - \code{mday}, \code{week}, \code{isoweek}, \code{isoyear}, \code{month}, \code{quarter}, - and \code{year} return integer values - for second, minute, hour, day of year, day of week, - day of month, week, month, quarter, and year, respectively. - \code{yearmon} and \code{yearqtr} return double values representing - respectively \code{year + (month-1) / 12} and \code{year + (quarter-1) / 4}. - - \code{second}, \code{minute}, \code{hour} are taken directly from - the \code{POSIXlt} representation. - All other values are computed from the underlying integer representation - and comparable with the values of their \code{POSIXlt} representation - of \code{x}, with the notable difference that while \code{yday}, \code{wday}, - and \code{mon} are all 0-based, here they are 1-based. - -} -\references{ - - G. Grothendieck and T. Petzoldt, \dQuote{Date and Time Classes in R}, - R News, vol. 4, no. 1, June 2004. - - H. Wickham, https://gist.github.com/hadley/10238. - - ISO 8601, https://www.iso.org/iso/home/standards/iso8601.htm -} - -\author{ Tom Short, t.short@ieee.org } - -\seealso{ \code{\link{as.Date}}, \code{\link{as.POSIXct}}, - \code{\link{strptime}}, \code{\link{DateTimeClasses}} - -} - -\examples{ - -# create IDate: -(d <- as.IDate(""2001-01-01"")) - -# S4 coercion also works -identical(as.IDate(""2001-01-01""), methods::as(""2001-01-01"", ""IDate"")) - -# create ITime: -(t <- as.ITime(""10:45"")) - -# S4 coercion also works -identical(as.ITime(""10:45""), methods::as(""10:45"", ""ITime"")) - -(t <- as.ITime(""10:45:04"")) - -(t <- as.ITime(""10:45:04"", format = ""\%H:\%M:\%S"")) - -# ""24:00:00"" is parsed as ""00:00:00"" -as.ITime(""24:00:00"") - -# Workaround for end-of-day: add 1 second to ""23:59:59"" -as.ITime(""23:59:59"") + 1L - -as.POSIXct(""2001-01-01"") + as.ITime(""10:45"") - ---- - -\code{key} returns the \code{data.table}'s key if it exists; \code{NULL} if none exists. - -\code{haskey} returns \code{TRUE}/\code{FALSE} if the \code{data.table} has a key. -} -\usage{ -setkey(x, \dots, verbose=getOption(""datatable.verbose""), physical = TRUE) -setkeyv(x, cols, verbose=getOption(""datatable.verbose""), physical = TRUE) -setindex(\dots) -setindexv(x, cols, verbose=getOption(""datatable.verbose"")) -key(x) -indices(x, vectors = FALSE) -haskey(x) -} -\arguments{ -\item{x}{ A \code{data.table}. } -\item{\dots}{ The columns to sort by. Do not quote the column names. If \code{\dots} is missing (i.e. \code{setkey(DT)}), all the columns are used. \code{NULL} removes the key. } -\item{cols}{ A character vector of column names. For \code{setindexv}, this can be a \code{list} of character vectors, in which case each element will be applied as an index in turn. } -\item{verbose}{ Output status and information. } -\item{physical}{ \code{TRUE} changes the order of the data in RAM. \code{FALSE} adds an index. } -\item{vectors}{ \code{logical} scalar, default \code{FALSE}; when set to \code{TRUE}, a \code{list} of character vectors is returned, each referring to one index. } -} -\details{ -\code{setkey} reorders (i.e. sorts) the rows of a \code{data.table} by the columns -provided. The sort method used has developed over the years and we have contributed -to base R too; see \code{\link[base]{sort}}. Generally speaking we avoid any type -of comparison sort (other than insert sort for very small input) preferring instead -counting sort and forwards radix. We also avoid hash tables. - -Note that \code{setkey} always uses ""C-locale""; see the Details in the help for \code{\link{setorder}} for more on why. - -The sort is \emph{stable}; i.e., the order of ties (if any) is preserved. - -For character vectors, \code{data.table} takes advantage of R's internal global string cache, also exported as \code{\link{chorder}}. -} - -\section{Keys vs. Indices}{ -Setting a key (with \code{setkey}) and an index (with \code{setindex}) are similar, but have very important distinctions. - -Setting a key physically reorders the data in RAM. - -Setting an index computes the sort order, but instead of applying the reordering, simply \emph{stores} this computed ordering. That means that multiple indices can coexist, and that the original row order is preserved. -} - -\section{Good practice}{ -In general, it's good practice to use column names rather than numbers. This is -why \code{setkey} and \code{setkeyv} only accept column names. -If you use column numbers then bugs (possibly silent) can more easily creep into -your code as time progresses if changes are made elsewhere in your code; e.g., if -you add, remove or reorder columns in a few months time, a \code{setkey} by column -number will then refer to a different column, possibly returning incorrect results -with no warning. (A similar concept exists in SQL, where \code{""select * from ...""} is considered poor programming style when a robust, maintainable system is -required.) - -If you really wish to use column numbers, it is possible but -deliberately a little harder; e.g., \code{setkeyv(DT,names(DT)[1:2])}. - -If you want to subset rows based on values of an integer key column, it should be done with the dot (\code{.}) syntax, because integers are otherwise interpreted as row numbers (see example). - ---- - -\section{Development and Verbosity Options}{ - \describe{ - \item{\code{datatable.quiet}}{A logical, default \code{FALSE}. The master switch to suppress all - \code{data.table} status messages, including the startup message.} - \item{\code{datatable.verbose}}{A logical, default \code{FALSE}. If \code{TRUE}, \code{data.table} will - print detailed diagnostic information as it processes a query.} - \item{\code{datatable.enlist}}{Experimental feature. Default is \code{NULL}. If set to a function - (e.g., \code{list}), the \code{j} expression can return a \code{list}, which will then - be ""enlisted"" into columns in the result.} - } -} - -\section{Back-compatibility Options}{ - \describe{ - \item{\code{datatable.old.matrix.autoname}}{Logical, default \code{FALSE}. Governs how the output of - expressions like \code{data.table(x=1, cbind(1))} will be named. When \code{TRUE}, it will be named - \code{V1}, otherwise it will be named \code{V2}. - } - } -} - -\seealso{ - \code{\link[base]{options}}, - \code{\link[base]{getOption}}, - \code{\link{data.table}} -} - -\keyword{data} -\keyword{utilities} - ---- - -7. Efficient conversion of `xts` to data.table. Closes [#882](https://github.com/Rdatatable/data.table/issues/882). Check examples in `?as.xts.data.table` and `?as.data.table.xts`. Thanks to @jangorecki for the PR. - - 8. `rbindlist` gains `idcol` argument which can be used to generate an index column. If `idcol=TRUE`, the column is automatically named `.id`. Instead you can also provide a column name directly. If the input list has no names, indices are automatically generated. Closes [#591](https://github.com/Rdatatable/data.table/issues/591). Also thanks to @KevinUshey for filing [#356](https://github.com/Rdatatable/data.table/issues/356). - - 9. A new helper function `uniqueN` is now implemented. It is equivalent to `length(unique(x))` but much faster. It handles `atomic vectors`, `lists`, `data.frames` and `data.tables` as input and returns the number of unique rows. Closes [#884](https://github.com/Rdatatable/data.table/issues/884). Gains by argument. Closes [#1080](https://github.com/Rdatatable/data.table/issues/1080). Closes [#1224](https://github.com/Rdatatable/data.table/issues/1224). Thanks to @DavidArenburg, @kevinmistry and @jangorecki. - - 10. Implemented `transpose()` to transpose a list and `tstrsplit` which is a wrapper for `transpose(strsplit(...))`. This is particularly useful in scenarios where a column has to be split and the resulting list has to be assigned to multiple columns. See `?transpose` and `?tstrsplit`, [#1025](https://github.com/Rdatatable/data.table/issues/1025) and [#1026](https://github.com/Rdatatable/data.table/issues/1026) for usage scenarios. Closes both #1025 and #1026 issues. - * Implemented `type.convert` as suggested by Richard Scriven. Closes [#1094](https://github.com/Rdatatable/data.table/issues/1094). - - 11. `melt.data.table` - * can now melt into multiple columns by providing a list of columns to `measure.vars` argument. Closes [#828](https://github.com/Rdatatable/data.table/issues/828). Thanks to Ananda Mahto for the extended email discussions and ideas on generating the `variable` column. - * also retains attributes wherever possible. Closes [#702](https://github.com/Rdatatable/data.table/issues/702) and [#993](https://github.com/Rdatatable/data.table/issues/993). Thanks to @richierocks for the report. - * Added `patterns.Rd`. Closes [#1294](https://github.com/Rdatatable/data.table/issues/1294). Thanks to @MichaelChirico. - - 12. `.SDcols` - * understands `!` now, i.e., `DT[, .SD, .SDcols=!""a""]` now works, and is equivalent to `DT[, .SD, .SDcols = -c(""a"")]`. Closes [#1066](https://github.com/Rdatatable/data.table/issues/1066). - * accepts logical vectors as well. If length is smaller than number of columns, the vector is recycled. Closes [#1060](https://github.com/Rdatatable/data.table/issues/1060). Thanks to @StefanFritsch. - - 13. `dcast` can now: - * cast multiple `value.var` columns simultaneously. Closes [#739](https://github.com/Rdatatable/data.table/issues/739). - * accept multiple functions under `fun.aggregate`. Closes [#716](https://github.com/Rdatatable/data.table/issues/716). - * supports optional column prefixes as mentioned under [this SO post](https://stackoverflow.com/q/26225206/559784). Closes [#862](https://github.com/Rdatatable/data.table/issues/862). Thanks to @JohnAndrews. - * works with undefined variables directly in formula. Closes [#1037](https://github.com/Rdatatable/data.table/issues/1037). Thanks to @DavidArenburg for the MRE. - * Naming conventions on multiple columns changed according to [#1153](https://github.com/Rdatatable/data.table/issues/1153). Thanks to @MichaelChirico for the FR. - * also has a `sep` argument with default `_` for backwards compatibility. [#1210](https://github.com/Rdatatable/data.table/issues/1210). Thanks to @dbetebenner for the FR. - ---- - -test(11.05, cbindlist(list(data.table(a=1L), data.table(), data.table(d=2L), data.table(f=3L))), data.table(a=1L, d=2L, f=3L)) -## codecov -test(12.01, cbindlist(data.frame(a=1L)), error=""must be a list"") -test(12.02, cbindlist(TRUE), error=""must be a list"") -test(12.03, cbindlist(list(data.table(a=1L), 1L)), error=""is not a data.table"") -test(12.04, options = c(datatable.verbose=TRUE), cbindlist(list(data.table(a=1:2), data.table(b=1:2))), data.table(a=1:2, b=1:2), output=""cbindlist.*took"") -test(12.05, cbindlist(list(data.table(), data.table(a=1:2), data.table(b=1:2))), data.table(a=1:2, b=1:2)) -test(12.06, cbindlist(list(data.table(), data.table(a=1:2), list(b=1:2))), data.table(a=1:2, b=1:2)) -test(12.07, cbindlist(list(data.table(a=integer()), list(b=integer()))), data.table(a=integer(), b=integer())) -## duplicated names -test(12.08, cbindlist(list(data.table(a=1L, b=2L), data.table(b=3L, d=4L))), data.table(a=1L, b=2L, b=3L, d=4L)) -local({ - # also test that keys, indices are wiped - ans = cbindlist(list(setindexv(data.table(a=2:1, b=1:2), ""a""), data.table(a=1:2, b=2:1, key=""a""), data.table(a=2:1, b=1:2))) - test(12.09, ans, data.table(a=2:1, b=1:2, a=1:2, b=2:1, a=2:1, b=1:2)) - test(12.10, indices(ans), NULL) -}) -## recycling, first ensure cbind recycling that we want to match to -test(12.11, cbind(data.table(x=integer()), data.table(a=1:2)), data.table(x=c(NA_integer_, NA), a=1:2)) -test(12.12, cbind(data.table(x=1L), data.table(a=1:2)), data.table(x=c(1L, 1L), a=1:2)) -test(12.13, cbindlist(list(data.table(a=integer()), data.table(b=1:2))), error=""Recycling.*not yet implemented"") -test(12.14, cbindlist(list(data.table(a=1L), data.table(b=1:2))), error=""Recycling.*not yet implemented"") -test(12.15, setcbindlist(list(data.table(a=integer()), data.table(b=1:2))), error=""have to have the same number of rows"") -test(12.16, setcbindlist(list(data.table(a=1L), data.table(b=1:2))), error=""have to have the same number of rows"") - -## retain indices -local({ - l = list( - data.table(id1=1:5, id2=5:1, id3=1:5, v1=1:5), - data.table(id4=5:1, id5=1:5, v2=1:5), - data.table(id6=5:1, id7=1:5, v3=1:5), - data.table(id8=5:1, id9=5:1, v4=1:5) - ) - setkeyv(l[[1L]], ""id1"") - setindexv(l[[1L]], list(""id1"", ""id2"", ""id3"", c(""id1"", ""id2"", ""id3""))) - setindexv(l[[3L]], list(""id6"", ""id7"")) - setindexv(l[[4L]], ""id9"") - ii = lapply(l, indices) - ans = cbindlist(l) - test(13.1, key(ans), ""id1"") - test(13.2, indices(ans), c(""id1"", ""id2"", ""id3"", ""id1__id2__id3"", ""id6"", ""id7"", ""id9"")) - test(13.3, ii, lapply(l, indices)) ## this tests that original indices have not been touched, shallow_duplicate in mergeIndexAttrib -}) -test(13.4, cbindlist(list(data.table(a=1:2), data.table(b=3:4, key=""b""))), data.table(a=1:2, b=3:4, key=""b"")) -# TODO(#7116): this could be supported -# test(13.5, cbindlist(list(data.table(a=1:2, key=""a""), data.table(b=3:4, key=""b""))), data.table(a=1:2, b=3:4, key=c(""a"", ""b""))) - -# mergepair - -## test copy-ness argument in mergepair - ---- - -## data.table [v1.12.8](https://github.com/Rdatatable/data.table/milestone/15?closed=1) (09 Dec 2019) - -### NEW FEATURES - -1. `DT[, {...; .(A,B)}]` (i.e. when `.()` is the final item of a multi-statement `{...}`) now auto-names the columns `A` and `B` (just like `DT[, .(A,B)]`) rather than `V1` and `V2`, [#2478](https://github.com/Rdatatable/data.table/issues/2478) [#609](https://github.com/Rdatatable/data.table/issues/609). Similarly, `DT[, if (.N>1) .(B), by=A]` now auto-names the column `B` rather than `V1`. Explicit names are unaffected; e.g. `DT[, {... y= ...; .(A=C+y)}, by=...]` named the column `A` before, and still does. Thanks also to @renkun-ken for his go-first strong testing which caught an issue not caught by the test suite or by revdep testing, related to NULL being the last item, [#4061](https://github.com/Rdatatable/data.table/issues/4061). - -### BUG FIXES - -1. `frollapply` could segfault and exceed R's C protect limits, [#3993](https://github.com/Rdatatable/data.table/issues/3993). Thanks to @DavisVaughan for reporting and fixing. - -2. `DT[, sum(grp), by=grp]` (i.e. aggregating the same column being grouped) could error with `object 'grp' not found`, [#3103](https://github.com/Rdatatable/data.table/issues/3103). Thanks to @cbailiss for reporting. - -### NOTES - -1. Links in the manual were creating warnings when installing HTML, [#4000](https://github.com/Rdatatable/data.table/issues/4000). Thanks to Morgan Jacob. - -2. Adjustments for R-devel (R 4.0.0) which now has reference counting turned on, [#4058](https://github.com/Rdatatable/data.table/issues/4058) [#4093](https://github.com/Rdatatable/data.table/issues/4093). This motivated early release to CRAN because every day CRAN tests every package using the previous day's changes in R-devel; a much valued feature of the R ecosystem. It helps R-core if packages can pass changes in R-devel as soon as possible. Thanks to Luke Tierney for the notice, and for implementing reference counting which we look forward to very much. - -3. C internals have been standardized to use `PRI[u|d]64` to print `[u]int64_t`. This solves new warnings from `gcc-8` on Windows with `%lld`, [#4062](https://github.com/Rdatatable/data.table/issues/4062), in many cases already working around `snprintf` on Windows not supporting `%zu`. Release procedures have been augmented to prevent any internal use of `llu`, `lld`, `zu` or `zd`. - -4. `test.data.table()` gains `showProgress=interactive()` to suppress the thousands of `Running test id ...` lines displayed by CRAN checks when there are warnings or errors. - - -## data.table [v1.12.6](https://github.com/Rdatatable/data.table/milestone/18?closed=1) (18 Oct 2019) - -### BUG FIXES - -1. `shift()` on a `nanotime` with the default `fill=NA` now fills a `nanotime` missing value correctly, [#3945](https://github.com/Rdatatable/data.table/issues/3945). Thanks to @mschubmehl for reporting and fixing in PR [#3942](https://github.com/Rdatatable/data.table/pull/3942). - -2. Compilation failed on CRAN's MacOS due to an older version of `zlib.h/zconf.h` which did not have `z_const` defined, [#3939](https://github.com/Rdatatable/data.table/issues/3939). Other open-source projects unrelated to R have experienced this problem on MacOS too. We have followed the common practice of removing `z_const` to support the older `zlib` versions, and data.table's release procedures have gained a `grep` to ensure `z_const` isn't used again by accident in future. The library `zlib` is used for `fwrite`'s new feature of multithreaded compression on-the-fly; see item 3 of 1.12.4 below. - ---- - -Otras dos opciones controlan la optimización a nivel global, incluido el uso de índices: - -```r -options(datatable.optimize=2L) -options(datatable.optimize=3L) -``` - -`options(datatable.optimize=2L)` desactivará por completo la optimización de filtros, mientras que `options(datatable.optimize=3L)` la reactivará. Estas opciones afectan a muchas más optimizaciones y, por lo tanto, no deben usarse cuando solo se necesita controlar los índices. Más información en `?datatable.optimize`. - -# Operaciones *por referencia* - -Al comparar funciones `set*`, solo tiene sentido medir la primera ejecución. Estas funciones actualizan su entrada por referencia, por lo que las ejecuciones posteriores utilizarán la `data.table` ya procesada, lo que sesgará los resultados - -Para proteger su `data.table` de la actualización por referencia, puede usar las funciones `copy` o `data.table:::shallow`. Tenga en cuenta que `copy` puede ser muy costoso, ya que requiere duplicar el objeto completo. Es poco probable que queramos incluir el tiempo de duplicación en la tarea que estamos evaluando. - -# Intentar comparar los procesos atómicos - -Si su punto de referencia está destinado a ser publicado, será mucho más esclarecedor si lo divide para medir el tiempo de los procesos atómicos. De esta manera, sus lectores pueden ver cuánto tiempo se dedicó a leer los datos de la fuente, limpiarlos, transformarlos realmente y exportar los resultados. Por supuesto, si su punto de referencia está destinado a presentar un *flujo de trabajo de extremo a extremo*, entonces tiene todo el sentido presentar el tiempo general. Sin embargo, separar el tiempo de los pasos individuales es útil para comprender qué pasos son los principales cuellos de botella de un flujo de trabajo. Hay otros casos en los que el punto de referencia atómico podría no ser deseable, por ejemplo, al *leer un csv*, seguido de *agrupar*. R requiere llenar *la caché de cadena global de R*, lo que agrega sobrecarga adicional al importar datos de caracteres a una sesión de R. Por otro lado, la *caché de cadena global* podría acelerar procesos como *agrupar*. En tales casos, al comparar R con otros lenguajes, podría ser útil incluir el tiempo total. - -# Evite la coerción de clase - -A menos que esto sea lo que realmente quiera medir, debe preparar objetos de entrada de la clase esperada para cada herramienta que esté evaluando - -# evitar `microbenchmark(..., times=100)` - -Repetir un benchmark muchas veces no suele ofrecer la imagen más clara para las herramientas de procesamiento de datos. Por supuesto, tiene mucho sentido para cálculos más atómicos, pero esta no es una buena representación de la forma más común en que se utilizarán realmente estas herramientas, es decir, para las tareas de procesamiento de datos, que consisten en lotes de transformaciones proporcionadas secuencialmente, cada una ejecutada una vez. Matt dijo una vez: - -> Soy muy cauteloso con los puntos de referencia medidos en tiempos inferiores a 1 segundo. Prefiero 10 segundos o más para una sola ejecución, lo que se logra aumentando el tamaño de los datos. Un recuento de repeticiones de 500 es alarmante. De 3 a 5 ejecuciones deberían ser suficientes para convencer con datos más grandes. La sobrecarga de llamadas y el tiempo de recolección de basura afectan las inferencias a esta escala tan pequeña. - -Esto es muy válido. Cuanto menor sea la medición de tiempo, mayor será el ruido relativo. El ruido se genera por el envío de métodos, la inicialización de paquetes/clases, etc. El punto de referencia debe centrarse principalmente en casos de uso reales. - -# procesamiento multiproceso - -Uno de los principales factores que probablemente afecte a los tiempos es el número de subprocesos disponibles para su sesión de R. En versiones recientes de `data.table`, algunas funciones están paralelizadas. Puede controlar el número de subprocesos que desea utilizar con `setDTthreads` - ---- - -Deux autres options permettent de contrôler l'optimisation de manière globale, y compris l'utilisation d'index : - -```r -options(datatable.optimize=2L) -options(datatable.optimize=3L) -``` - -`options(datatable.optimize=2L)` désactivera complètement l'optimisation des sous-ensembles, tandis que `options(datatable.optimize=3L)` la réactivera. Ces options affectent beaucoup plus d'optimisations et ne devraient donc pas être utilisées lorsque seul le contrôle des index est nécessaire. Plus d'informations dans `?datatable.optimize`. - -# opérations *par référence* - -Lors de l'évaluation des fonctions `set*`, il n'est utile de mesurer que la première exécution. Ces fonctions mettent à jour leur entrée par référence, donc les exécutions suivantes utiliseront le fichier `data.table` déjà traité, ce qui faussera les résultats. - -Protéger votre `data.table` d'une mise à jour par des opérations de référence peut être réalisé en utilisant les fonctions `copy` ou `data.table:::shallow`. Soyez conscient que `copy` peut être très coûteux car il doit dupliquer l'objet entier. Il est peu probable que nous voulions inclure le temps de duplication dans le temps de la tâche réelle que nous benchmarkons. - -# tenter d'étalonner les processus atomiques - -Si votre analyse comparative est destinée à être publiée, elle sera beaucoup plus utile si vous la divisez pour mesurer la durée des processus atomiques. De cette manière, vos lecteurs pourront voir combien de temps a été consacré à la lecture des données à partir de la source, au nettoyage, à la transformation proprement dite et à l'exportation des résultats. Bien sûr, si votre benchmark est destiné à présenter un *flux de travail de bout en bout*, il est tout à fait logique de présenter le temps global. Néanmoins, la séparation des temps des étapes individuelles est utile pour comprendre quelles étapes sont les principaux goulots d'étranglement d'un flux de travail. Il existe d'autres cas où le benchmarking atomique n'est pas souhaitable, par exemple lors de la *lecture d'un csv*, suivie d'un *regroupement*. R nécessite de remplir le *cache global de chaînes de caractères de R*, ce qui ajoute une surcharge supplémentaire lors de l'importation de données de caractères dans une session R. D'un autre côté, le *cache global de chaînes de caractères* peut accélérer des processus tels que le *regroupement*. Dans de tels cas, lorsque l'on compare R à d'autres langages, il peut être utile d'inclure le temps total. - -# éviter la coercition de classe - -Si ce n'est pas ce que vous voulez vraiment mesurer, vous devez préparer des objets d'entrée de la classe attendue pour chaque outil que vous comparez. - -# éviter `microbenchmark(..., times=100)` - -Répéter un benchmark plusieurs fois ne donne généralement pas l'image la plus claire des outils de traitement des données. Bien sûr, c'est parfaitement logique pour les calculs plus atomiques, mais ce n'est pas une bonne représentation de la manière la plus courante dont ces outils seront utilisés, à savoir pour les tâches de traitement des données, qui consistent en des lots de transformations fournies de manière séquentielle, chacune exécutée une fois. Matt a dit un jour : - -> Je me méfie beaucoup des benchmarks qui prennent moins d'une seconde. Je préfère de loin 10 secondes ou plus pour une seule exécution, obtenues en augmentant la taille des données. Un nombre de répétitions de 500 tire la sonnette d'alarme. 3 à 5 exécutions devraient suffire à convaincre sur des données plus importantes. Le coût des appels de fonctions et le temps nécessaire au GC affectent les calculs à une si petite échelle. - -Ceci est tout à fait vrai. Plus la mesure du temps est petite, plus le bruit est important, de manière relative. Le bruit est généré par le dispatching des méthodes, l'initialisation de packages/classes, etc. Le benchmark devrait se concentrer sur des scénarios d'utilisation réelle. - -# traitement multithread - ---- - -4. The translations submitted for 1.16.0 are now actually shipped with the package -- our deepest apologies to the translators for the omission. We have added a CI check to ensure that the .mo binaries which get shipped with the package are always up-to-date. - -## data.table [v1.16.0](https://github.com/Rdatatable/data.table/milestone/30) (25 August 2024) - -### BREAKING CHANGES - -1. `droplevels(in.place=TRUE)` is deprecated in favor of calling `setdroplevels()`, [#6014](https://github.com/Rdatatable/data.table/issues/6014). Given the associated risks/pain points, we strongly prefer all in-place/by-reference behavior within data.table come from functions `set*` (and `:=`) to make it as clear as possible that inputs are mutable. See below and `?setdroplevels` for more. - -2. `` `[.data.table` `` is un-exported again. This was exported to support an experimental feature (`DT()` functional form of `[`) that never made it to release, but we forgot to claw back this export in the NAMESPACE; sorry about that. We didn't find anyone calling the method directly (which is inadvisable to begin with). - -### NEW FEATURES - -1. We continue to consider user feedback to prioritize development. See [#3189](https://github.com/Rdatatable/data.table/issues/3189) for the current list of most-requested issues. In this release we add five highly-requested features: - - a. Using `dt[, names(.SD) := lapply(.SD, fx)]` now works to update all columns, [#795](https://github.com/Rdatatable/data.table/issues/795). Of course this also works when `.SD` is only a subset of the columns: `dt[, names(.SD) := lapply(.SD, fx), .SDcols = is.numeric]`. Thanks to @brodieG for the report, 20 or so others for chiming in, and @ColeMiller1 for PR. - - b. `fread()` now supports automatic detection of `dec` (as either `.` or `,`, the latter being [common in many places in Europe, Africa, and South America](https://en.wikipedia.org/wiki/Decimal_separator)); this behavior is now the default, i.e. `dec='auto'`, [#2431](https://github.com/Rdatatable/data.table/issues/2431). Thanks @mattdowle for the original issue, 50 or more others for expressing support, and @MichaelChirico for the fix. - - c. `fcase()` supports vectors in `default=` (so the default can vary by row) and `default=` is now lazily evaluated, [#4258](https://github.com/Rdatatable/data.table/issues/4258). Thanks @sindribaldur for the feature request, @shrektan for doing most of the implementation, and @MichaelChirico for sewing things up. Thanks also to @DavisVaughan for some design guidance before release to remove an extraneous feature, [#6352](https://github.com/Rdatatable/data.table/issues/6352). - - d. `[.data.table` gains argument `showProgress`, allowing users to toggle progress printing for slow ""group by"" operations, [#3060](https://github.com/Rdatatable/data.table/issues/3060). The progress bar reports information such as the number of groups processed, total groups, total time elapsed and estimated time until completion. This feature doesn't apply to `GForce`-optimized operations. Thanks to @eatonya and @zachmayer for filing FRs, and to everyone else that up-voted/chimed in on the issue. Thanks to @joshhwuu for the PR. - - e. `rbindlist(l, use.names=TRUE)` and `rbind()` now work correctly on columns with different class attributes across the inputs for certain classes such as `Date`, `IDate`, `ITime`, `POSIXct` and `AsIs` with matched columns of similar classes, e.g., `rbind(data.table(d = Sys.Date()), data.table(d = as.IDate(Sys.Date()-1)))`. The conversion is done automatically and the class attribute of the final column is determined by the first class attribute encountered in the binding list, [#5309](https://github.com/Rdatatable/data.table/issues/5309), [#4934](https://github.com/Rdatatable/data.table/issues/4934), [#5391](https://github.com/Rdatatable/data.table/issues/5391). - ---- - -\name{datatable.optimize} -\alias{datatable-optimize} -\alias{datatable.optimize} -\alias{data.table-optimize} -\alias{data.table.optimize} -\alias{gforce} -\alias{GForce} -\alias{autoindex} -\alias{autoindexing} -\alias{auto-index} -\alias{auto-indexing} -\alias{rounding} -\title{Optimisations in data.table} -\description{ -\code{data.table} internally optimises certain expressions in order to improve -performance. This section briefly summarises those optimisations. - -Note that there's no additional input needed from the user to take advantage -of these optimisations. They happen automatically. - -Run the code under the \emph{example} section to get a feel for the performance -benefits from these optimisations. - -Note that for all optimizations involving efficient sorts, the caveat mentioned -in \code{\link{setorder}} applies -- whenever data.table does the sorting, -it does so in ""C-locale"". This has some subtle implications; see Examples. - -} -\details{ -\code{data.table} reads the global option \code{datatable.optimize} to figure -out what level of optimisation is required. The default value \code{Inf} -activates \emph{all} available optimisations. - -For \code{getOption(""datatable.optimize"") >= 1}, these are the optimisations: - -\itemize{ - \item The base function \code{order} is internally replaced with - \code{data.table}'s \emph{fast ordering}. That is, \code{DT[order(\dots)]} - gets internally optimised to \code{DT[forder(\dots)]}. - - \item The expression \code{DT[, lapply(.SD, fun), by=.]} gets optimised - to \code{DT[, list(fun(a), fun(b), \dots), by=.]} where \code{a,b, \dots} are - columns in \code{.SD}. This improves performance tremendously. - - \item Similarly, the expression \code{DT[, c(.N, lapply(.SD, fun)), by=.]} - gets optimised to \code{DT[, list(.N, fun(a), fun(b), \dots)]}. \code{.N} is - just for example here. - - \item \code{base::mean} function is internally optimised to use - \code{data.table}'s \code{fastmean} function. \code{mean()} from \code{base} - is an S3 generic and gets slow with many groups. -} - -For \code{getOption(""datatable.optimize"") >= 2}, additional optimisations are implemented on top of the optimisations already shown above. - -\itemize{ - - \item Expressions in \code{j} which contain only the functions - \code{min, max, mean, median, var, sd, sum, prod, first, last, head, tail} (for example, - \code{DT[, list(mean(x), median(x), min(y), max(y)), by=z]}), they are very - effectively optimised using what we call \emph{GForce}. These functions - are automatically replaced with a corresponding GForce version - with pattern \code{g*}, e.g., \code{prod} becomes \code{gprod}. - - Normally, once the rows belonging to each group are identified, the values - corresponding to the group are gathered and the \code{j}-expression is - evaluated. This can be improved by computing the result directly without - having to gather the values or evaluating the expression for each group - (which can get costly with large number of groups) by implementing it - specifically for a particular function. As a result, it is extremely fast. - - \item In addition to all the functions above, \code{.N} is also optimised to - use GForce, when used separately or when combined with the functions mentioned - above. Note further that GForce-optimized functions must be used separately, - i.e., code like \code{DT[ , max(x) - min(x), by=z]} will \emph{not} currently - be optimized to use \code{gmax, gmin}. - - \item Expressions of the form \code{DT[i, j, by]} are also optimised when - \code{i} is a \emph{subset} operation and \code{j} is any/all of the functions - discussed above. -} - ---- - -27. The default number of over-allocated spare column pointer slots has been increased from 64 to 1024. The wasted memory overhead (if never used) is insignificant (0.008 MB). The advantage is that adding a large number of columns by reference using := or set() inside a loop will not now saturate as quickly and need reallocating. An alleviation to issue [#1633](https://github.com/Rdatatable/data.table/issues/1633). See `?alloc.col` for how to change this default yourself. Accordingly, the warning 'attempt to reduce allocation has been ignored' has been downgraded to a message in verbose mode. That typically occurs when using (not recommended) `[<-` and `$<-` methods on data.table. The `n=` argument to `alloc.col()` is now simply the number of spare column slots to over-allocate (on creation and reallocation). An expression using `ncol(DT)` is still ok but now deprecated. - - 28. `?IDateTime` now makes clear that `wday`, `yday` and `month` are all 1- (not 0- as in `POSIXlt`) based, [#1658](https://github.com/Rdatatable/data.table/issues/1658); thanks @MichaelChirico. - - 29. Fixed misleading documentation of `?uniqueN`, [#1746](https://github.com/Rdatatable/data.table/issues/1746). Thanks @SymbolixAU. - - 30. `melt.data.table` restricts column names printed during warning messages to a maximum of five, [#1752](https://github.com/Rdatatable/data.table/issues/1752). Thanks @franknarf1. - - 31. data.table's `setNumericRounding` has a default value of 0, which means ordering, joining and grouping of numeric values will be done at *full precision* by default. Handles [#1642](https://github.com/Rdatatable/data.table/issues/1642), [#1728](https://github.com/Rdatatable/data.table/issues/1728), [#1463](https://github.com/Rdatatable/data.table/issues/1463), [#485](https://github.com/Rdatatable/data.table/issues/485). - - 32. Subsets with S4 objects in `i` are now faster, [#1438](https://github.com/Rdatatable/data.table/issues/1438). Thanks @DCEmilberg. - - 33. When formula RHS is `.` and multiple functions are provided to `fun.aggregate`, column names of the cast data.table columns don't have the `.` in them, as it doesn't add any useful information really, [#1821](https://github.com/Rdatatable/data.table/issues/1821). Thanks @franknarf1. - - 34. Function names are added to column names on cast data.tables only when more than one function is provided, [#1810](https://github.com/Rdatatable/data.table/issues/1810). Thanks @franknarf1. - - 35. The option `datatable.old.bywithoutby` to restore the old default has been removed. As warned 2 years ago in release notes and explicitly warned about for 1 year when used. Search down this file for the text 'bywithoutby' to see previous notes on this topic. - - 36. Using `with=FALSE` together with `:=` was deprecated in v1.9.4 released 2 years ago (Oct 2014). As warned then in release notes (see below) this is now a warning with advice to wrap the LHS of `:=` with parenthesis; e.g. `myCols=c(""colA"",""colB""); DT[,(myCols):=1]`. In the next release, this warning message will be an error message. - - 37. Using `nomatch` together with `:=` now warns that it is ignored. - - 38. Logical `i` is no longer recycled. Instead an error message if it isn't either length 1 or `nrow(DT)`. This was hiding more bugs than was worth the rare convenience. The error message suggests to recycle explicitly; i.e. `DT[rep(,length=.N),...]`. - - 39. Thanks to Mark Landry and Michael Chirico for finding and reporting a problem in dev before release with auto `with=FALSE` (item 3 above) when `j` starts with with `!` or `-`, [#1864](https://github.com/Rdatatable/data.table/issues/1864). Fixed and tests added. - ---- - -* Prettier printing of list columns. The first 6 items of atomic vectors - are collapsed with "","" followed by a trailing "","" if there are more than - 6, FR#1608. This difference to data.frame has been added to FAQ 2.17. - Embedded objects (such as a data.table) print their class name only to avoid - seemingly mangled output, bug #1803. Thanks to Yike Lu for reporting. - For example: - > data.table(x=letters[1:3], - y=list( 1:10, letters[1:4], data.table(a=1:3,b=4:6) )) - x y - 1: a 1,2,3,4,5,6, - 2: b a,b,c,d - 3: c - - * Warnings added when joining character to factor, and factor to character. - Character to character is now preferred in joins and needs no coercion. - Even so, these coercions have been made much more efficient by taking - a shallow copy of i internally, avoiding a full deep copy of i. - - * Ordered subsets now retain x's key. Always for logical and keyed i, using - base::is.unsorted() for integer and unkeyed i. Implements FR#295. - - * mean() is now automatically optimized, #1231. This can speed up grouping - by 20 times when there are a large number of groups. See wiki point 3, which - is no longer needed to know. Turn off optimization by setting - options(datatable.optimize=0). - - * DT[,lapply(.SD,...),by=...] is now automatically optimized, #2067. This can speed - up applying a function by column by group, by over 20 times. See wiki point 5 - which is no longer needed to know. In other words: - DT[,lapply(.SD,sum),by=grp] - is now just as fast as : - DT[,list(x=sum(x),y=sum(y)),by=grp] - Don't forget to use .SDcols when a subset of columns is needed. - - * The package is now Byte Compiled (when installed in R 2.14.0 or later). Several - internal speed improvements were made in this version too, such as avoiding - internal copies. If you find 1.8.2 is faster, before attributing that to Byte - Compilation, please install the package without Byte Compilation and compare - ceteris paribus. If you find cases where speed has slowed, please let us know. - - * sapply(DT,class) gets a significant speed boost by avoiding a call to unclass() - in as.list.data.table() called by lapply(DT,...), which copied the entire object. - Thanks to a question by user1393348 on Stack Overflow, implementing #2000. - https://stackoverflow.com/questions/10584993/r-loop-over-columns-in-data-table - - * The J() alias is now deprecated outside DT[...], but will still work inside - DT[...], as in DT[J(...)]. - J() is conflicting with function J() in package XLConnect (#1747) - and rJava (#2045). For data.table to change is easier, with some efficiency - advantages too. The next version of data.table will issue a warning from J() - when used outside DT[...]. The version after will remove it. Only then will - the conflict with rJava and XLConnect be resolved. - Please use data.table() directly instead of J(), outside DT[...]. - - * New DT[.(...)] syntax (in the style of package plyr) is identical to - DT[list(...)], DT[J(...)] and DT[data.table(...)]. We plan to add ..(), too, so - that .() and ..() are analogous to the file system's ./ and ../; i.e., .() - evaluates within the frame of DT and ..() in the parent scope. - - * New function rbindlist(l). This does the same as do.call(""rbind"",l), but much - faster. - -### BUG FIXES - - * DT[,f(.SD),by=colA] where f(x)=x[,colB:=1L] was a segfault, bug#1727. - This is now a graceful error to say that using := in .SD's j is - reserved for future use. This was already caught in most circumstances, - other than via f(.SD). Thanks to Leon Baum for reporting. Test added. - ---- - -\name{rowwiseDT} -\alias{rowwiseDT} -\title{ Create a data.table row-wise } -\description{ - \code{rowwiseDT} creates a \code{data.table} object by specifying a row-by-row layout. This is convenient and highly readable for small tables. -} -\usage{ -rowwiseDT(...) -} -\arguments{ - \item{...}{ Arguments that define the structure of a \code{data.table}. The column names come from named arguments (like \code{col=}), which must precede the data. See Examples. } -} -\value{ -A \code{data.table}. The default is for each column to return as a vector. However, if any entry has a length that is not one (e.g., \code{list(1, 2)}), the whole column will be converted to a list column. -} -\seealso{ - \code{\link{data.table}} -} -\examples{ -rowwiseDT( - A=,B=, C=, - 1, ""a"",2:3, - 2, ""b"",list(5) -) -} - ---- - -3. When `j` contains no unquoted variable names (whether column names or not), `with=` is now automatically set to `FALSE`. Thus, `DT[,1]`, `DT[,""someCol""]`, `DT[,c(""colA"",""colB"")]` and `DT[,100:109]` now work as we all expect them to; i.e., returning columns, [#1188](https://github.com/Rdatatable/data.table/issues/1188), [#1149](https://github.com/Rdatatable/data.table/issues/1149). Since there are no variable names there is no ambiguity as to what was intended. `DT[,colName1:colName2]` no longer needs `with=FALSE` either since that is also unambiguous. That is a single call to the `:` function so `with=TRUE` could make no sense, despite the presence of unquoted variable names. These changes can be made since nobody can be using the existing behaviour of returning back the literal `j` value since that can never be useful. This provides a new ability and should not break any existing code. Selecting a single column still returns a 1-column data.table (not a vector, unlike `data.frame` by default) for type consistency for code (e.g. within `DT[...][...]` chains) that can sometimes select several columns and sometime one, as has always been the case in data.table. In future, `DT[,myCols]` (i.e. a single variable name) will look for `myCols` in calling scope without needing to set `with=FALSE` too, just as a single symbol appearing in `i` does already. The new behaviour can be turned on now by setting the tersely named option: `options(datatable.WhenJisSymbolThenCallingScope=TRUE)`. The default is currently `FALSE` to give you time to change your code. In this future state, one way (i.e. `DT[,theColName]`) to select the column as a vector rather than a 1-column data.table will no longer work leaving the two other ways that have always worked remaining (since data.table is still just a `list` after all): `DT[[""someCol""]]` and `DT$someCol`. Those base R methods are faster too (when iterated many times) by avoiding the small argument checking overhead inside the more flexible `DT[...]` syntax as has been highlighted in `example(data.table)` for many years. In the next release, `DT[,someCol]` will continue with old current behaviour but start to warn if the new option is not set. Then the default will change to TRUE to nudge you to move forward whilst still retaining a way for you to restore old behaviour for this feature only, whilst still allowing you to benefit from other new features of the latest release without changing your code. Then finally after an estimated 2 years from now, the option will be removed. - -### NEW FEATURES - - 1. `fwrite()` - parallel .csv writer: - * Thanks to Otto Seiskari for the initial pull request [#580](https://github.com/Rdatatable/data.table/issues/580) that provided C code, R wrapper, manual page and extensive tests. - * From there Matt parallelized and specialized C functions for writing integer/numeric exactly matching `write.csv` between 2.225074e-308 and 1.797693e+308 to 15 significant figures, dates (between 0000-03-01 and 9999-12-31), times down to microseconds in POSIXct, automatic quoting, `bit64::integer64`, `row.names` and `sep2` for `list` columns where each cell can itself be a vector. See [this blog post](https://blog.h2o.ai/2016/04/fast-csv-writing-for-r/) for implementation details and benchmarks. - * Accepts any `list` of same length vectors; e.g. `data.frame` and `data.table`. - * Caught in development before release to CRAN: thanks to Francesco Grossetti for [#1725](https://github.com/Rdatatable/data.table/issues/1725) (NA handling), Torsten Betz for [#1847](https://github.com/Rdatatable/data.table/issues/1847) (rounding of 9.999999999999998) and @ambils for [#1903](https://github.com/Rdatatable/data.table/issues/1903) (> 1 million columns). - * `fwrite` status was tracked here: [#1664](https://github.com/Rdatatable/data.table/issues/1664) - ---- - -\name{setkey} -\alias{setkey} -\alias{setkeyv} -\alias{key} -\alias{haskey} -\alias{setindex} -\alias{setindexv} -\alias{indices} -\title{ Create key on a data.table } -\description{ -\code{setkey} sorts a \code{data.table} and marks it as sorted with an -attribute \code{""sorted""}. The sorted columns are the key. The key can be any -number of columns. The data is always sorted in \emph{ascending} order with \code{NA}s -(if any) always first. The table is changed \emph{by reference} and there is -no memory used for the key (other than marking which columns the data is sorted by). - -There are three reasons \code{setkey} is desirable: -\itemize{ - \item binary search and joins are faster when they detect they can use an existing key - \item grouping by a leading subset of the key columns is faster because the groups are already gathered contiguously in RAM - \item simpler shorter syntax; e.g. \code{DT[""id"",]} finds the group ""id"" in the first column of \code{DT}'s key using binary search. It may be helpful to think of a key as super-charged rownames: multi-column and multi-type. -} - -\code{NA}s are always first because: -\itemize{ - \item \code{NA} is internally \code{INT_MIN} (a large negative number) in R. Keys and indexes are always in increasing order so if \code{NA}s are first, no special treatment or branch is needed in many \code{data.table} internals involving binary search. It is not optional to place \code{NA}s last for speed, simplicity and robustness of internals at C level. - \item if any \code{NA}s are present then we believe it is better to display them up front (rather than hiding them at the end) to reduce the risk of not realizing \code{NA}s are present. -} - -In \code{data.table} parlance, all \code{set*} functions change their input -\emph{by reference}. That is, no copy is made at all other than for temporary -working memory, which is as large as one column. The only other \code{data.table} -operator that modifies input by reference is \code{\link{:=}}. Check out the -\code{See Also} section below for other \code{set*} functions \code{data.table} -provides. - -\code{setindex} creates an index for the provided columns. This index is simply an -ordering vector of the dataset's rows according to the provided columns. This order vector -is stored as an attribute of the \code{data.table} and the dataset retains the original order -of rows in memory. See the \href{../doc/datatable-secondary-indices-and-auto-indexing.html}{\code{vignette(""datatable-secondary-indices-and-auto-indexing"")}} for more details. - -\code{key} returns the \code{data.table}'s key if it exists; \code{NULL} if none exists. - ---- - -* := now works with a logical i subset; e.g., - DT[x==1,y:=x] - Thanks to Muhammad Waliji for reporting. - -### USER VISIBLE CHANGES - - * Error message ""column of i is not internally type integer"" - is now more helpful adding ""i doesn't need to be keyed, just - convert the (likely) character column to factor"". Thanks to - Christoph_J for his SO question. - - -## data.table v1.7.0 - -### NEW FEATURES - - * data.table() now accepts list columns directly rather than - needing to add list columns to an existing data.table; e.g., - - DT = data.table(x=1:3,y=list(4:6,3.14,matrix(1:12,3))) - - Thanks to Branson Owen for reminding. As before, list columns - can be created via grouping; e.g., - - DT = data.table(x=c(1,1,2,2,2,3,3),y=1:7) - DT2 = DT[,list(list(unique(y))),by=x] - DT2 - x V1 - [1,] 1 1, 2 - [2,] 2 3, 4, 5 - [3,] 3 6, 7 - - and list columns can be grouped; e.g., - - DT2[,sum(unlist(V1)),by=list(x%%2)] - x V1 - [1,] 1 16 - [2,] 0 12 - - Accordingly, one item has been added to FAQ 2.17 (differences - between data.frame and data.table): data.frame(list(1:2,""k"",1:4)) - creates 3 columns, data.table creates one list column. - - * subset, transform and within now retain keys when the expression - does not 'touch' key columns, implementing FR #1341. - - * Recycling list() items on RHS of := now works; e.g., - - DT[,1:4:=list(1L,NULL),with=FALSE] - # set columns 1 and 3 to 1L and remove columns 2 and 4 - - * Factor columns on LHS of :=, [<- and $<- can now be assigned - new levels; e.g., - - DT = data.table(A=c(""a"",""b"")) - DT[2,""A""] <- ""c"" # adds new level automatically - DT[2,A:=""c""] # same (faster) - DT$A = ""newlevel"" # adds new level and recycles it - - Thanks to Damian Betebenner and Chris Neff for highlighting. - To change the type of a column, provide a full length RHS (i.e. - 'replace' the column). - -### BUG FIXES - - * := with i all FALSE no longer sets the whole column, fixing - bug #1570. Thanks to Chris Neff for reporting. - - * 0 length by (such as NULL and character(0)) now behave as - if by is missing, fixing bug #1599. This is useful when by - is dynamic and a 'dont group' needs to be represented. - Thanks to Chris Neff for reporting. - - * NULL j no longer results in 'inconsistent types' error, but - instead returns no rows for that group, fixing bug #1576. - - * matrix i is now an error rather than using i as if it were a - vector and obtaining incorrect results. It was undocumented that - matrix might have been an acceptable type. matrix i is - still acceptable in [<-; e.g., - DT[is.na(DT)] <- 1L - and this now works rather than assigning to non-NA items in some - cases. - - * Inconsistent [<- behaviour is now fixed (#1593) so these examples - now work : - DT[x == ""a"", ]$y <- 0L - DT[""a"", ]$y <- 0L - But, := is highly encouraged instead for speed; i.e., - DT[x == ""a"", y:=0L] - DT[""a"", y:=0L] - Thanks to Leon Baum for reporting. - - * unique on an unsorted table now works, fixing bug #1601. - Thanks to a question by Iterator on Stack Overflow. - - * Bug fix #1534 in v1.6.5 (see NEWS below) only worked if data.table - was higher than IRanges on the search() path, despite the item in - NEWS stating otherwise. Fixed. - - * Compatibility with package sqldf (which can call do.call(""rbind"",...) - on an empty ""..."") is fixed and test added. data.table was switching - on list(...)[[1]] rather than ..1. Thanks to RYogi for reporting #1623. - -### USER VISIBLE CHANGES - ---- - -#: assign.c:457 -msgid """" -""It appears that at some earlier point, names of this data.table have been "" -""reassigned. Please ensure to use setnames() rather than names<- or "" -""colnames<-. Otherwise, please report to data.table issue tracker."" -msgstr """" -""Parece que em algum momento anterior, os nomes desta data.table foram "" -""reatribuídos. Certifique-se de usar setnames() em vez de names<- ou "" -""colnames<-. Caso contrário, por favor, relate isso no rastreador de "" -""problemas do data.table."" - -#: assign.c:464 -msgid """" -""It appears that at some earlier point, attributes of this data.table have "" -""been reassigned. Please use setattr(DT, name, value) rather than attr(DT, "" -""name) <- value. If that doesn't apply to you, please report your case to the "" -""data.table issue tracker."" -msgstr """" -""Parece que em algum momento anterior, atributos desta data.table foram "" -""reatribuídos. Favor usar setattr(DT, nome, valor) em vez de attr(DT, nome) "" -""<- valor. Se isso não se aplicar ao seu caso, por favor, relate isso no "" -""rastreador de problemas do data.table."" - -#: assign.c:496 -#, c-format -msgid """" -""RHS for item %d has been duplicated because MAYBE_REFERENCED==%d "" -""MAYBE_SHARED==%d ALTREP==%d, but then is being plonked. length(values)==%d; "" -""length(cols)==%d\n"" -msgstr """" -""O lado direito (RHS) para o item %d foi duplicado porque "" -""MAYBE_REFERENCED==%d MAYBE_SHARED==%d ALTREP==%d, mas depois está sendo "" -""plonked. length(values)==%d; length(cols)==%d\n"" - -#: assign.c:501 -#, c-format -msgid """" -""Direct plonk of unnamed RHS, no copy. MAYBE_REFERENCED==%d, "" -""MAYBE_SHARED==%d\n"" -msgstr """" -""Plonk direto de lado direito (RHS) sem nome, sem cópia. "" -""MAYBE_REFERENCED==%d, MAYBE_SHARED==%d\n"" - -#: assign.c:570 -#, c-format -msgid """" -""Dropping index '%s' as it doesn't have '__' at the beginning of its name. It "" -""was very likely created by v1.9.4 of data.table.\n"" -msgstr """" -""Descartando o índice '%s' porque ele não tem '__' no início do nome. Muito "" -""provavelmente foi criado pela versão 1.9.4 do data.table.\n"" - -#: assign.c:615 assign.c:631 -#, c-format -msgid ""Dropping index '%s' due to an update on a key column\n"" -msgstr """" -""Descartando o índice '%s' devido a uma atualização em uma coluna-chave\n"" - -#: assign.c:624 -#, c-format -msgid ""Shortening index '%s' to '%s' due to an update on a key column\n"" -msgstr """" -""Reduzindo o índice '%s' para '%s' devido a uma atualização em uma coluna-"" -""chave\n"" - -#: assign.c:682 -#, c-format -msgid ""(column %d named '%s')"" -msgstr ""(coluna %d de nome '%s')"" - -#: assign.c:716 -#, c-format -msgid """" -""Cannot assign 'factor' to '%s'. Factors can only be assigned to factor, "" -""character or list columns."" -msgstr """" -""Não é possível atribuir 'factor' a '%s'. Os fatores só podem ser atribuídos "" -""a colunas de fator, caractere ou lista."" - -#: assign.c:731 -#, c-format -msgid """" -""Assigning factor numbers to target vector. But %d is outside the level range "" -""[1,%d]"" -msgstr """" -""Atribuindo números de fator ao vetor alvo. Mas %d está fora do intervalo de "" -""níveis [1,%d]"" - -#: assign.c:733 -#, c-format -msgid """" -""Assigning factor numbers to column %d named '%s'. But %d is outside the "" -""level range [1,%d]"" -msgstr """" -""Atribuindo números de fator à coluna %d de nome '%s'. Mas %d está fora do "" -""intervalo de níveis [1,%d]"" - -#: assign.c:743 -#, c-format -msgid """" -""Assigning factor numbers to target vector. But %f is outside the level range "" -""[1,%d], or is not a whole number."" -msgstr """" -""Atribuindo números de fator ao vetor alvo. Mas %f está fora do intervalo de "" -""níveis [1,%d] ou não é um número inteiro."" - -#: assign.c:745 -#, c-format -msgid """" -""Assigning factor numbers to column %d named '%s'. But %f is outside the "" -""level range [1,%d], or is not a whole number."" -msgstr """" -""Atribuindo números de fator à coluna %d de nome '%s'. Mas %f está fora do "" -""intervalo de níveis [1,%d], ou não é um número inteiro."" - ---- - -## He observado que `base::cbind.data.frame` (y `base::rbind.data.frame`) parecen ser modificados por data.table. ¿Cómo es posible? ¿Por qué? - -Era una solución temporal de último recurso antes de que se corrigiera la resolución de métodos S3 de rbind y cbind en R >= 4.0.0. En esencia, el problema residía en que `data.table` hereda de `data.frame`, *y* `base::cbind` y `base::rbind` (de forma única) realizan su propia resolución S3 internamente, como se documenta en `?cbind`. La solución alternativa para `data.table` consistía en añadir un bucle `for` al inicio de cada función directamente en `base`. Esta modificación se realizaba dinámicamente; es decir, se obtuvo la definición `base` de `cbind.data.frame`, se añadía el bucle `for` al inicio y luego se volvía a asignar a `base`. Esta solución se diseñó para ser robusta ante varias definiciones de `base::cbind.data.frame` en diferentes versiones de R, incluyendo cambios futuros desconocidos. Funcionó correctamente. Los requisitos en conflicto eran: - - - `cbind(DT, DF)` debe funcionar. La definición de `cbind.data.table` no funcionaba porque `base::cbind` realizaba su propia resolución S3 y requería (antes de R 4.0.0) que el *primer* método `cbind` para cada objeto que se le pasa fuera *idéntico*. Esto no se cumple en `cbind(DT, DF)`, ya que el primer método para `DT` es `cbind.data.table`, pero el primer método para `DF` es `cbind.data.frame`. `base::cbind` entonces fallaba en su código interno `bind`, que parece tratar `DT` como una `lista` normal y devuelve una salida `matrix` de aspecto extraño e inutilizable. Véase [a continuación](#cbinderror). No podemos simplemente aconsejar a los usuarios que no llamen a `cbind(DT, DF)` porque paquetes como `ggplot2` hacen dicha llamada ([prueba 167.2](https://github.com/Rdatatable/data.table/blob/master/inst/tests/tests.Rraw#L444-L447)). - - - Esto, naturalmente, llevó a intentar enmascarar `cbind.data.frame`. Dado que un data.table es un `data.frame`, `cbind` encontraría el mismo método para `DT` y `DF`. Sin embargo, esto tampoco funcionó porque `base::cbind` parece encontrar primero los métodos en `base`; *es decir*, `base::cbind.data.frame` no es enmascarable. - - - Finalmente, intentamos enmascarar `cbind` (v1.6.5 y v1.6.6). Esto permitió que `cbind(DT, DF)` funcionara, pero introdujo problemas de compatibilidad con el paquete `IRanges`, ya que `IRanges` también enmascara `cbind`. Funcionaba si `IRanges` estaba en una posición inferior a data.table en la ruta `search()`, pero si `IRanges` estaba en una posición superior a data.table, `cbind` nunca se llamaría y la salida de `matrix`, de aspecto extraño, volvía a aparecer (ver [abajo](#cbinderror)). - -Muchas gracias al equipo central de R por solucionar el problema en septiembre de 2019. data.table v1.12.6+ ya no aplica la solución alternativa en R >= 4.0.0. - -## He leído sobre la resolución de métodos (p. ej., ""merge"" puede o no derivar a ""merge.data.table""), pero ¿cómo sabe R cómo derivar? ¿Son los puntos significativos o especiales? ¿Cómo sabe R a qué función resolver y cuándo? {#r-dispatch} - ---- - -\item{optimize}{ A vector of different optimization levels to test. The code in \code{x} will be run once for each optimization level, with \code{options(datatable.optimize=optimize)} set accordingly. All optimization levels must pass the test for the overall test to pass. If no \code{y} is supplied, the results from the different levels are compared to each other for equality. If a \code{y} is supplied, the results from each level are compared to \code{y}. } -} -\note{ - \code{NA_real_} and \code{NaN} are treated as equal, use \code{identical} if distinction is needed. See examples below. - ---- - -#: data.table.R:139 -#, c-format -msgid ""Item '%s' not found in names of input list"" -msgstr ""Не могу найти «%s» среди имён входного списка"" - -#: data.table.R:159 -#, c-format -msgid """" -""[ was called on a data.table in an environment that is not data.table-aware "" -""(i.e. cedta()), but '%s' was used, implying the owner of this call really "" -""intended for data.table methods to be called. See vignette('datatable-"" -""importing') for details on properly importing data.table."" -msgstr """" -""Метод [ был вызван для data.table из окружения, не поддерживающего data."" -""table (см. ?cedta()), но было передано '%s', что означает, что вызывающей "" -""функции действительно нужен метод data.table. Подробнее о правильном "" -""использовании data.table в пакетах см. в vignette('datatable-importing')."" - -#: data.table.R:170 -#, c-format -msgid ""verbose must be logical or integer"" -msgstr ""«verbose» должно быть логическим или целочисленным"" - -#: data.table.R:171 -#, c-format -msgid ""verbose must be length 1 non-NA"" -msgstr ""«verbose» должно быть длины 1 и не-NA"" - -#: data.table.R:179 -#, c-format -msgid ""Ignoring by/keyby because 'j' is not supplied"" -msgstr ""Игнорирую «by»/«keyby», потому что «j» не был передан"" - -#: data.table.R:193 -#, c-format -msgid ""When by and keyby are both provided, keyby must be TRUE or FALSE"" -msgstr ""Когда «by» и «keyby» оба переданы, «keyby» должно быть TRUE либо FALSE"" - -#: data.table.R:196 data.table.R:261 data.table.R:351 -msgid ""Argument '%s' after substitute: %s"" -msgstr ""Аргумент «%s» после подстановки: %s"" - -#: data.table.R:205 -#, c-format -msgid """" -""When on= is provided but not i=, on= must be a named list or data.table|"" -""frame, and a natural join (i.e. join on common names) is invoked. Ignoring "" -""on= which is '%s'."" -msgstr """" -""Если указано on=, но не i=, on= должно быть именованным списком или data."" -""table|frame; тогда будет выполнено натуральное соединение (т. е. по столбцам "" -""с общими именами). Игнорирую on=, которое имеет значение '%s'."" - -#: data.table.R:218 -#, c-format -msgid """" -""i and j are both missing so ignoring the other arguments. This warning will "" -""be upgraded to error in future."" -msgstr """" -""i и j отсутствуют, поэтому игнорирую остальные аргументы. В будущем это "" -""предупреждение будет преобразовано в ошибку."" - -#: data.table.R:222 -#, c-format -msgid ""mult argument can only be 'first', 'last', 'all' or 'error'"" -msgstr ""аргумент «mult» должен быть 'first', 'last', 'all' или 'error'"" - -#: data.table.R:224 -#, c-format -msgid """" -""roll must be a single TRUE, FALSE, positive/negative integer/double "" -""including +Inf and -Inf or 'nearest'"" -msgstr """" -""roll должен быть TRUE, FALSE, положительным/отрицательным числом, включая "" -""+Inf и -Inf, либо 'nearest'"" - -#: data.table.R:226 -#, c-format -msgid ""roll is '%s' (type character). Only valid character value is 'nearest'."" -msgstr """" -""«roll» - это '%s' (строка). Единственное допустимое строковое значение - "" -""'nearest'."" - -#: data.table.R:231 -#, c-format -msgid ""rollends must be a logical vector"" -msgstr ""«rollends» должно быть логическим вектором"" - -#: data.table.R:232 -#, c-format -msgid ""rollends must be length 1 or 2"" -msgstr ""«rollends» должно быть длины 1 или 2"" - -#: data.table.R:240 -#, c-format -msgid """" -""nomatch= must be either NA or NULL (or 0 for backwards compatibility which "" -""is the same as NULL but please use NULL)"" -msgstr """" -""nomatch= должно быть либо NA, либо NULL (ранее 0 значило то же, что сейчас "" -""значит NULL)"" - -#: data.table.R:243 -#, c-format -msgid ""which= must be a logical vector length 1. Either FALSE, TRUE or NA."" -msgstr ""which= должен быть FALSE, TRUE или NA_logical_."" - -#: data.table.R:244 -#, c-format -msgid """" -""which==%s (meaning return row numbers) but j is also supplied. Either you "" -""need row numbers or the result of j, but only one type of result can be "" -""returned."" -msgstr """" -""which==%s (значит, вернуть номера строк), но также передан j. Вы можете "" -""запросить либо одно, либо другое, но не всё сразу."" - ---- - -\name{data.table-package} -\alias{data.table-package} -\docType{package} -\alias{data.table} -\alias{Ops.data.table} -\alias{is.na.data.table} -\alias{[.data.table} -\alias{.} -\alias{.(} -\alias{.()} -\alias{..} -\title{ Enhanced data.frame } -\description{ - \code{data.table} \emph{inherits} from \code{data.frame}. It offers fast and memory efficient: file reader and writer, aggregations, updates, equi, non-equi, rolling, range and interval joins, in a short and flexible syntax, for faster development. - - It is inspired by \code{A[B]} syntax in \R where \code{A} is a matrix and \code{B} is a 2-column matrix. Since a \code{data.table} \emph{is} a \code{data.frame}, it is compatible with \R functions and packages that accept \emph{only} \code{data.frame}s. - - Type \code{vignette(package=""data.table"")} to get started. The \href{../doc/datatable-intro.html}{Introduction to data.table} vignette introduces \code{data.table}'s \code{x[i, j, by]} syntax and is a good place to start. If you have read the vignettes and the help page below, please read the \href{https://github.com/Rdatatable/data.table/wiki/Support}{data.table support guide}. - - Please check the \href{https://github.com/Rdatatable/data.table/wiki}{homepage} for up to the minute live NEWS. - - Tip: one of the \emph{quickest} ways to learn the features is to type \code{example(data.table)} and study the output at the prompt. -} -\usage{ -data.table(\dots, keep.rownames=FALSE, check.names=FALSE, key=NULL, stringsAsFactors=FALSE) - -\method{[}{data.table}(x, i, j, by, keyby, with = TRUE, - nomatch = NA, - mult = ""all"", - roll = FALSE, - rollends = if (roll==""nearest"") c(TRUE,TRUE) - else if (roll>=0) c(FALSE,TRUE) - else c(TRUE,FALSE), - which = FALSE, - .SDcols, - verbose = getOption(""datatable.verbose""), # default: FALSE - allow.cartesian = getOption(""datatable.allow.cartesian""), # default: FALSE - drop = NULL, on = NULL, env = NULL, - showProgress = getOption(""datatable.showProgress"", interactive())) -} -\arguments{ - \item{\dots}{ Just as \code{\dots} in \code{\link{data.frame}}. Usual recycling rules are applied to vectors of different lengths to create a list of equal length vectors.} - - \item{keep.rownames}{ If \code{\dots} is a \code{matrix} or \code{data.frame}, \code{TRUE} will retain the rownames of that object in a column named \code{rn}.} - - \item{check.names}{ Just as \code{check.names} in \code{\link{data.frame}}.} - - \item{key}{ Character vector of one or more column names which is passed to \code{\link{setkey}}.} - - \item{stringsAsFactors}{Logical (default is \code{FALSE}). Convert all \code{character} columns to \code{factor}s?} - - \item{x}{ A \code{data.table}.} - - \item{i}{ Integer, logical or character vector, single column numeric \code{matrix}, expression of column names, \code{list}, \code{data.frame} or \code{data.table}. - - \code{integer} and \code{logical} vectors work the same way they do in \code{\link{[.data.frame}} except logical \code{NA}s are treated as FALSE. - - \code{expression} is evaluated within the frame of the \code{data.table} (i.e. it sees column names as if they are variables) and can evaluate to any of the other types. - - \code{character}, \code{list} and \code{data.frame} input to \code{i} is converted into a \code{data.table} internally using \code{\link{as.data.table}}. - - If \code{i} is a \code{data.table}, the columns in \code{i} to be matched against \code{x} can be specified using one of these ways: - - \itemize{ - \item \code{on} argument (see below). It allows for both \code{equi-} and the newly implemented \code{non-equi} joins. - - \item If not, \code{x} \emph{must be keyed}. Key can be set using \code{\link{setkey}}. If \code{i} is also keyed, then first \emph{key} column of \code{i} is matched against first \emph{key} column of \code{x}, second against second, etc.. - ---- - -# related to !is.integer(verbose) -test(99.1, data.table(a=1,b=2)[1,1, verbose=1], error=""verbose must be logical or integer"") -test(99.2, data.table(a=1,b=2)[1,1, verbose=1:2], error=""verbose must be length 1 non-NA"") -test(99.3, data.table(a=1,b=2)[1,1, verbose=NA], error=""verbose must be length 1 non-NA"") -test(99.4, options=c(datatable.verbose=1), coerceAs(1, 2L), error=""verbose option must be length 1 non-NA logical or integer"") - ---- - -```{r} -key(flights) -flights[.(""LGA"", ""TPA""), .(arr_delay)] -``` - -* Los *índices de fila* correspondientes a `origin == ""LGA""` y `dest == ""TPA""` se obtienen utilizando un *filtro basado en clave*. - -* Una vez que tenemos los índices de fila, revisamos `j`, que solo requiere la columna `arr_delay`. Así que simplemente seleccionamos la columna `arr_delay` para esos *índices de fila* de la misma manera que vimos en la viñeta [`vignette(""datatable-intro"", package=""data.table"")`](datatable-intro.html). - -* Podríamos haber devuelto el resultado usando `with = FALSE` también. - - ```r - flights[.(""LGA"", ""TPA""), ""arr_delay"", with = FALSE] - ``` - -### b) Encadenamiento - -#### -- Con el resultado obtenido anteriormente, utilizar encadenamiento para ordenar la columna en orden decreciente - -```{r} -flights[.(""LGA"", ""TPA""), .(arr_delay)][order(-arr_delay)] -``` - -### c) Calcular o *hacer* en `j` - -#### -- Encontrar el retraso máximo de llegada correspondiente a `origin = ""LGA""` y `dest = ""TPA""`. - -```{r} -flights[.(""LGA"", ""TPA""), max(arr_delay)] -``` - -*Podemos verificar que el resultado es idéntico al primer valor (486) del ejemplo anterior. - -### d) *sub-asignar* por referencia usando `:=` en `j` - -Ya vimos este ejemplo en la viñeta [`vignette(""datatable-reference-semantics"", package=""data.table"")`](datatable-reference-semantics.html). Veamos todas las `horas` disponibles en la *data.table* `flights`: - -```{r} -# get all 'hours' in flights -flights[, sort(unique(hour))] -``` - -Observamos que hay un total de 25 valores únicos en los datos. Parece que hay tanto *0* como *24* horas. Reemplacemos *24* por *0*, pero esta vez usando *key*. - -```{r} -setkey(flights, hour) -key(flights) -flights[.(24), hour := 0L] -key(flights) -``` - -* Primero configuramos `key` como `hour`. Esto reordena los `flights` según la columna `hour` y marca esa columna como `key`. - -* Ahora podemos filtrar en `hour` usando la notación `.()`. Filtramos para el valor *24* y obtenemos los *índices de fila* correspondientes. - -* Y en esos índices de fila, reemplazamos la columna `key` con el valor `0`. - -* Dado que reemplazamos los valores en la columna *key*, la tabla de datos `flights` ya no se ordena por `hour`. Por lo tanto, la clave se ha eliminado automáticamente al establecerla en NULL. - -Ahora, no debería haber ningún *24* en la columna ""hora"". - -```{r} -flights[, sort(unique(hour))] -``` - -### e) Agregación utilizando `by` - -Primero, establezcamos nuevamente la clave en `origin, dest`. - -```{r} -setkey(flights, origin, dest) -key(flights) -``` - -#### Obtener el retraso máximo de salida para cada mes correspondiente a `origin = ""JFK""`. Ordenar el resultado por mes. - -```{r} -ans <- flights[""JFK"", max(dep_delay), keyby = month] -head(ans) -key(ans) -``` - -* Filtramos en la columna `clave` *origen* para obtener los *índices de fila* correspondientes a *""JFK""*. - -* Una vez que obtenemos los índices de fila, solo necesitamos dos columnas: `month` para agrupar y `dep_delay` para obtener `max()` para cada grupo. Por lo tanto, la optimización de consulta de *data.table* filtra solo aquellas dos columnas correspondientes a los *índices de fila* obtenidos en `i`, para mayor velocidad y eficiencia de memoria. - -* Y en ese filtro, agrupamos por *mes* y calculamos `max(dep_delay)`. - -* Usamos `keyby` para clasificar automáticamente ese resultado por *mes*. Ahora entendemos lo que significa. Además de ordenar, también establece *mes* como la columna `key`. - -## 3. Argumentos adicionales: `mult` y `nomatch` - -### a) El argumento *mult* - -Podemos elegir, para cada consulta, si se deben devolver *todas* (""all"") las filas coincidentes, o solo la *primera* (""first"") o la *última* (""last"") mediante el argumento `mult`. El valor predeterminado es *""all""*, el que hemos visto hasta ahora. - -#### -- Obtener solo la primera fila coincidente de todas las filas donde `origin` coincide con *""JFK""* y `dest` coincide con *""MIA""* - -```{r} -flights[.(""JFK"", ""MIA""), mult = ""first""] -``` - ---- - -Link Title Author 2025.09 Manipuler des données avec data.table Pierre-Yves Berrard, Lino Galiana et Olivier Meslin 2025.05 Syntax conversion: data.table vs. base vs. dplyr Vincent Arel-Bundock 2024.11 Data wrangling with data.table Stata2R: Kyle Butts , Nick Huntington-Klein , and Grant McDermott 2024.11 Julia DataFrames.jl comparison with data.table authors of DataFrames.jl docs 2024.11 data.table.threads Anirban Chetia 2024.10 Comparing data.table reshape to duckdb and polars Toby Dylan Hocking 2024.10 Benchmarking rolling window functions in R Mikkel Roald-Arbøl 2024.09 Mutation testing for data.table Anirban Chetia 2024.08 Collapse reshape benchmark Toby Dylan Hocking 2024.07 Benchmarking a change in data.table Toby Dylan Hocking 2024.06 data.table for the Google Summer of Code 2024 (Joshua Wu) Joshua Wu 2024.02 Column assignment and reference semantics in data.table Toby Dylan Hocking 2024.02 NSF project activities Anirban Chetia 2024.02 new programming with data.table John MacKintosh 2024.02 more .I in data.table John MacKintosh 2024.01 .I in data.table John MacKintosh 2024.01 Reshape performance comparison Toby Dylan Hocking 2023.12 Comparing data table to frame for row subset Toby Dylan Hocking 2023.12 non-equi joins in data.table John MacKintosh 2023.11 Some pedagogical elements of computer programming for data science: A comparison of three approaches to teaching the R language David Shilane , Nicole Di Crecchio , Nicole L. Lorenzetti 2023.11 data.table CRAN diffs: Verifying consistency between CRAN and github Toby Dylan Hocking 2023.10 data.table asymptotic timings Toby Dylan Hocking 2023.03 A Coding Translation to Increase the Efficiency of Programmatic Data Analyses David Shilane 2023.02 Pivoting data in R with tidyr and data.table John MacKintosh 2022.11 dplyr 1.1.0 is coming soon Davis Vaughan 2022.11 Handling larger than memory data with {arrow} and {duckdb} David Lucey 2022.11 R Package Release History: Extracting and plotting data from CRAN web site Toby Dylan Hocking 2022.10 Efficiency comparison of dplyr and tidyr functions vs base R Manuel Teodoro Tenango 2022.08 modifying columns in datatable with lapply John MacKintosh 2022.08 Simulating data from a non-linear function by specifying a handful of points Keith Goldfeld 2022.06 Timing data.table Operations Thomas Shafer 2022.06 Shuffling Columns With data.table Thomas Shafer 2022.06 A quirk when using data.table? Kenneth Tay 2022.05 Comparing performances of CSV to RDS, Parquet, and Feather file formats in R Tomaž Kaštrun 2022.04 Loading a large, messy csv using data.table fread with cli tools David Lucey 2022.04 Greatly revised edition of tidyverse skeptic Original 2019.07 below: Ctrl-F ""matloff"" Norm Matloff 2022.03 Shiny: Fast Data Loading with fst Philipp Probst 2021.12 Optimising dplyr Tom Jemmett 2021.11 Should I Move to a Database? Roel M. Hogervorst 2021.10 Most Starred and Forked GitHub Repos for Data Science and R Kenneth Leung 2021.10 fwf without the faff John MacKintosh 2021.10 Simulating the Squid Game bridge scene in R John Paul Helveston 2021.09 Calculating hotel occupancy with R John MacKintosh 2021.08 Exploring Stock Market Listing Mortality since 1986 David Lucey 2021.08 Introducing the fastverse: An Extensible Suite of High-Performance and Low-Dependency Packages for Statistical Computing and Data Manipulation Sebastian Krantz 2021.08 Well Well Well My Excel John MacKintosh 2021.08 Cutting down code in dplyr and data.table John MacKintosh 2021.08 Code performance in R: Working with large datasets Mira Céline Klein 2021.07 Time Travel with py datatable 1.0 Gregory Kanevsky 2021.06 DTPlyr – easier data.table for DPLYR users Gary Hutson 2021.06 Stress testing reshape operations on list columns Toby Dylan Hocking 2021.06 Wide-to-tall Data Reshaping Using Regular Expressions and the nc Package Toby Dylan Hocking 2021.05 Update about data reshaping and visualization in R and python Toby Dylan Hocking 2021.05 Hamburg RUG: A professional trading - ---- - -В этом случае неэкспортированная функция `[.data.table` превратится в вызов -`[.data.frame` в качестве меры предосторожности, поскольку `data.table` не -имеет возможности узнать, что родительский пакет осведомлен о том, что он -пытается выполнить вызов синтаксиса API запросов `data.table` (что может -привести к неожиданному поведению, поскольку структура вызовов -`[.data.frame` и `[.data.table` принципиально отличается: например, -последний имеет гораздо больше аргументов). - -Если Вы предпочитаете такой подход к разработке пакетов, задайте переменную -`.datatable.aware = TRUE` в любом месте исходного кода R (экспортировать её -не нужно). Это сообщит `data.table`, что Вы, как разработчик пакета, -спроектировали свой код так, чтобы намеренно полагаться на функциональность -`data.table`, даже если это может быть не очевидно при просмотре вашего -файла `NAMESPACE`. - -`data.table` на лету определяет, знает ли вызывающая функция, что она -обращается к `data.table`, с помощью внутренней функции `cedta` -(«**C**alling **E**nvironment is **D**ata **T**able **A**ware», окружение -вызова функции знает про `data.table`), которая, помимо проверки -`?getNamespaceImports` для вашего пакета, также проверяет существование этой -переменной (и некоторые другие вещи). - -## Дополнительная информация о зависимостях - -Более официальную документацию о зависимостях пакетов и способах их -объявления можно найти в официальном руководстве: [Writing R -Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html). - -## Импорт функций на C из data.table - -Некоторые из внутренне используемых подпрограмм на C теперь экспортированы -для другого кода на C и могут быть использованы в пакетах R непосредственно -из кода на C. Подробнее о том, как это делать, см. в -[`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) и в -разделе [Writing R -Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) -_Linking to native routines in other packages_. - -## Импорт извне R {#non-r-api} - -Некоторые небольшие части Си-кода `data.table` были изолированы от R C API и -теперь могут быть использованы из приложений, не относящихся к R, путем -компоновки с файлами .so / .dll. Более подробная информация об этом будет -предоставлена позже, а пока вы можете изучить Си-код, который был изолирован -от R C API в -[src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) -и -[src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c). - -## Как преобразовать зависимость от data.table из Depends в Imports - -Чтобы преобразовать зависимость Вашего пакета от `data.table` типа `Depends` -в зависимость типа `Imports`, выполните следующие действия: - -### Шаг 0. Убедитесь, что ваш пакет изначально проходит R CMD check - -### Шаг 1. Обновите файл DESCRIPTION, переместив data.table из Depends в Imports - -**До:** -```dcf -Depends: - R (>= 3.5.0), - data.table -Imports: -``` - -**После:** -```dcf -Depends: - R (>= 3.5.0) -Imports: - data.table -``` - -### Шаг 2.1: Выполните команду `R CMD check` - -Запустите `R CMD check`, чтобы выявить недостающие импорты. Этот шаг: - -- Автоматически обнаруживает любые функции или символов из `data.table`, - которые не были импортированы явно. -- Отмечает отсутствующие специальные символы, такие как `.N`, `.SD` и `:=`. -- Сразу же пишет, что нужно добавить в файл NAMESPACE. - -Замечание: `R CMD check` ловит не все подобные случаи использования. В -частности, `R CMD check` пропускает некоторые символы/функции в формулах и -полностью пропустит собранные из текста выражения типа `parse(text = -""data.table(a = 1)"")`. Для обнаружения таких краевых случаев пакетам -потребуется хорошее покрытие тестами. - -### Шаг 2.2: Измените файл NAMESPACE - -Основываясь на результатах `R CMD check`, импортируйте из `data.table` все -необходимые функции, специальные символы, общие функции S3 и классы S4. - ---- - -#: data.table.R:760 -msgid ""column not found: %s"" -msgid_plural ""columns not found: %s"" -msgstr[0] ""列不存在: %s"" - -#: data.table.R:928 -#, fuzzy -#| msgid """" -#| ""The items in the 'by' or 'keyby' list are length(s) %s. Each must be "" -#| ""length %d; the same length as there are rows in x (after subsetting if i "" -#| ""is provided)."" -msgid """" -""The item in the 'by' or 'keyby' list is length %s. Each must be length %d; "" -""the same length as there are rows in x (after subsetting if i is provided)."" -msgid_plural """" -""The items in the 'by' or 'keyby' list have lengths %s. Each must be length "" -""%d; the same length as there are rows in x (after subsetting if i is "" -""provided)."" -msgstr[0] """" -""在'by'或'keyby'列表中的项长度为 %s 。每一项的长度须均为%d，即应与 x （或经 i "" -""筛选后的子集）中所包含行数相同。"" - -#: fmelt.R:27 -msgid ""Pattern not found: [%s]"" -msgid_plural ""Patterns not found: [%s]"" -msgstr[0] ""未找到下列 pattern：[%s]"" - -#: fread.R:354 -msgid ""stringsAsFactors=%s converted %d column: %s\n"" -msgid_plural ""stringsAsFactors=%s converted %d columns: %s\n"" -msgstr[0] """" - -#: merge.R:131 -msgid """" -""merge.data.table() received %d unnamed argument in '...' which will be "" -""ignored."" -msgid_plural """" -""merge.data.table() received %d unnamed arguments in '...' which will be "" -""ignored."" -msgstr[0] """" - -#: merge.R:138 -msgid """" -""merge.data.table() received %d unknown keyword argument which will be "" -""ignored: %s"" -msgid_plural """" -""merge.data.table() received %d unknown keyword arguments which will be "" -""ignored: %s"" -msgstr[0] """" - -#: merge.R:144 -msgid ""%d unnamed argument in '...'"" -msgid_plural ""%d unnamed arguments in '...'"" -msgstr[0] """" - -#: merge.R:145 -#, fuzzy -#| msgid ""Passed %d unknown and unnamed arguments."" -msgid ""%d unknown keyword argument"" -msgid_plural ""%d unknown keyword arguments"" -msgstr[0] ""传入了 %d 个未知和未命名的参数。"" - -#: print.data.table.R:51 -msgid ""Index: %s\n"" -msgid_plural ""Indices: %s\n"" -msgstr[0] ""索引(index): %s\n"" - -#: print.data.table.R:290 -msgid ""%d variable not shown: %s\n"" -msgid_plural ""%d variables not shown: %s\n"" -msgstr[0] """" - -#: setops.R:46 -msgid ""unsupported column type found in x or y: %s"" -msgid_plural ""unsupported column types found in x or y: %s"" -msgstr[0] ""找到不支持的列类型在 x 或 y: %s"" - -#: test.data.table.R:288 -msgid ""%d error out of %d. Search %s for test number %s. Duration: %s."" -msgid_plural """" -""%d errors out of %d. Search %s for test numbers %s. Duration: %s."" -msgstr[0] """" -""%2$d 中共产生 %1$d 个错误。搜索 %3$s 以定位测试编号 %4$s。用时：%5$s。"" - -#: test.data.table.R:298 -msgid ""Caught %d warning outside the test() calls:\n"" -msgid_plural ""Caught %d warnings outside the test() calls:\n"" -msgstr[0] """" - -#: utils.R:43 -#, fuzzy -#| msgid """" -#| ""%s has some duplicated column name(s): %s. Please remove or rename the "" -#| ""duplicate(s) and try again."" -msgid """" -""%s has duplicated column name %s. Please remove or rename the duplicate and "" -""try again."" -msgid_plural """" -""%s has duplicated column names %s. Please remove or rename the duplicates "" -""and try again."" -msgstr[0] ""%s 中有如下重复的列名：%s。请移除或者重命名重复项后重试。"" - ---- - -24. `setcolorder()` gains `before=` and `after=`, [#4358](https://github.com/Rdatatable/data.table/issues/4358). Thanks to Matthias Gomolka for the request, and both Benjamin Schwendinger and Xianghui Dong for implementing. Also thanks to Manuel López-Ibáñez for testing dev and mentioning needed documentation before release. - -25. `base::droplevels()` gains a fast method for `data.table`, [#647](https://github.com/Rdatatable/data.table/issues/647). Thanks to Steve Lianoglou for requesting, Boniface Kamgang and Martin Binder for testing, and Jan Gorecki and Benjamin Schwendinger for the PR. `fdroplevels()` for use on vectors has also been added. - -26. `shift()` now also supports `type=""cyclic""`, [#4451](https://github.com/Rdatatable/data.table/issues/4451). Arguments that are normally pushed out by `type=""lag""` or `type=""lead""` are re-introduced at this type at the first/last positions. Thanks to @RicoDiel for requesting, and Benjamin Schwendinger for the PR. - - ```R - # Usage - shift(1:5, n=-1:1, type=""cyclic"") - # [[1]] - # [1] 2 3 4 5 1 - # - # [[2]] - # [1] 1 2 3 4 5 - # - # [[3]] - # [1] 5 1 2 3 4 - - # Benchmark - x = sample(1e9) # 3.7 GB - microbenchmark::microbenchmark( - shift(x, 1, type=""cyclic""), - c(tail(x, 1), head(x,-1)), - times = 10L, - unit = ""s"" - ) - # Unit: seconds - # expr min lq mean median uq max neval - # shift(x, 1, type = ""cyclic"") 1.57 1.67 1.71 1.68 1.70 2.03 10 - # c(tail(x, 1), head(x, -1)) 6.96 7.16 7.49 7.32 7.64 8.60 10 - ``` - -27. `fread()` now supports ""0"" and ""1"" in `na.strings`, [#2927](https://github.com/Rdatatable/data.table/issues/2927). Previously this was not permitted since ""0"" and ""1"" can be recognized as boolean values. Note that it is still not permitted to use ""0"" and ""1"" in `na.strings` in combination with `logical01 = TRUE`. Thanks to @msgoussi for the request, and Benjamin Schwendinger for the PR. - -28. `setkey()` now supports type `raw` as value columns (not as key columns), [#5100](https://github.com/Rdatatable/data.table/issues/5100). Thanks Hugh Parsonage for requesting, and Benjamin Schwendinger for the PR. - -29. `shift()` is now optimized by group, [#1534](https://github.com/Rdatatable/data.table/issues/1534). Thanks to Gerhard Nachtmann for requesting, and Benjamin Schwendinger for the PR. Thanks to @neovom for testing dev and filing a bug report, [#5547](https://github.com/Rdatatable/data.table/issues/5547) which was fixed before release. This helped also in improving the logic for when to turn on optimization by group in general, making it more robust. - - ```R - N = 1e7 - DT = data.table(x=sample(N), y=sample(1e6,N,TRUE)) - shift_no_opt = shift # different name not optimized as a way to compare - microbenchmark( - DT[, c(NA, head(x,-1)), y], - DT[, shift_no_opt(x, 1, type=""lag""), y], - DT[, shift(x, 1, type=""lag""), y], - times=10L, unit=""s"") - # Unit: seconds - # expr min lq mean median uq max neval - # DT[, c(NA, head(x, -1)), y] 8.7620 9.0240 9.1870 9.2800 9.3700 9.4110 10 - # DT[, shift_no_opt(x, 1, type = ""lag""), y] 20.5500 20.9000 21.1600 21.3200 21.4400 21.5200 10 - # DT[, shift(x, 1, type = ""lag""), y] 0.4865 0.5238 0.5463 0.5446 0.5725 0.5982 10 - ``` - ---- - -# test regression on over-allocation (selfref) on unique() which uses new subsetDT() -bla <- data.table(x=c(1,1,2,2), y=c(1,1,1,1)) -test(1342, unique(bla)[, bla := 2L], data.table(x=c(1,2),y=1,bla=2L)) - -# blank and NA fields in logical columns -test(1343.1, fread(""A,B\n1,TRUE\n2,\n3,False""), data.table(A=1:3, B=c(""TRUE"","""",""False""))) -test(1343.2, fread(""A,B\n1,True\n2,\n3,false""), data.table(A=1:3, B=c(""True"","""",""false""))) -test(1343.3, fread(""A,B\n1,TRUE\n2,\n3,FALSE""), data.table(A=1:3, B=c(TRUE,NA,FALSE))) -test(1343.4, fread(""A,B\n1,True\n2,\n3,False""), data.table(A=1:3, B=c(TRUE,NA,FALSE))) -test(1343.5, fread(""A,B\n1,true\n2,\n3,false""), data.table(A=1:3, B=c(TRUE,NA,FALSE))) -test(1343.6, fread(""A,B\n1,true\n2,NA\n3,""), data.table(A=1:3, B=c(TRUE,NA,NA))) -test(1344.1, fread(""A,B\n1,2\n0,3\n,1\n"", logical01=FALSE), data.table(A=c(1L,0L,NA), B=c(2L,3L,1L))) -test(1344.2, fread(""A,B\n1,2\n0,3\n,1\n"", logical01=TRUE), data.table(A=c(TRUE,FALSE,NA), B=c(2L,3L,1L))) -test(1344.3, fread(""A,B\nY,2\nN,3\nNA,1\n"", logicalYN=FALSE), data.table(A=c('Y','N',NA), B=c(2L,3L,1L))) -test(1344.4, fread(""A,B\nY,2\nN,3\nNA,1\n"", logicalYN=TRUE), data.table(A=c(TRUE,FALSE,NA), B=c(2L,3L,1L))) -test(1344.5, fread(""A,B\nY,2\nN,3\n,1\n"", logicalYN=FALSE, na.strings=""""), data.table(A=c('Y','N',NA), B=c(2L,3L,1L))) -test(1344.6, fread(""A,B\nY,2\nN,3\n,1\n"", logicalYN=TRUE, na.strings=""""), data.table(A=c(TRUE,FALSE,NA), B=c(2L,3L,1L))) - -# .N now available in i -DT = data.table(a=1:3,b=1:6) -test(1348, DT[.N], DT[6]) -test(1349, DT[.N-1:3], DT[5:3]) -test(1350, DT[.N+1], DT[NA]) - -# Adding test to catch any future regressions - #734 -dt = data.table(id = rep(c('a','b'), each=2), val = rep(c(1,2,3), times=c(1,2,1))) -setkey(dt, id, val) -test(1351.1, dt[J(""a""), val], c(1,2)) -test(1351.2, dt[J('a'), range(val)], c(1,2)) - -# New feature: .() in j and .() in by -DT = data.table(a=1:3, b=1:6, c=LETTERS[1:6]) -test(1352.1, DT[,.(b)], DT[,list(b)]) -test(1352.2, DT[,.(b,c)], DT[,c(""b"",""c""),with=FALSE]) -test(1352.3, DT[,.(sum(b)),by=a], DT[,sum(b),by=a]) -test(1352.4, DT[,.(MySum=sum(b)), by=a], data.table(a=1:3, MySum=c(5L,7L,9L))) -test(1352.5, DT[,sum(b),by=.(a)], DT[,sum(b),by=a]) -test(1352.6, DT[,sum(b),by=.(a%%2)], DT[,sum(b),by=a%%2]) -test(1352.7, DT[,sum(b),by=.(Grp=a%%2)], DT[,sum(b),by=list(Grp=a%%2)]) -test(1352.8, DT[,sum(b),by=.(a%%2,c)], DT[,sum(b),by=list(a%%2,c)]) - -# that :=NULL together with i is now an error -DT = data.table(a=1:3, b=1:6, c=list(7, 8, 9, 8, 7, 6)) -test(1353.1, DT[2, b:=NULL], error=""When deleting columns, i should not be provided"") -test(1353.2, DT[2, c(""a"",""b""):=list(42, NULL)], error=""When deleting columns, i should not be provided"") -# #5526: friendlier error nudging to the correct way to sub-assign NULL to list columns -test(1353.3, DT[2, c := NULL], error=""Invalid attempt to delete a list column.*did you intend to add NULL"") -test(1353.4, DT[2, c := .(NULL)], error=""Invalid attempt to delete a list column.*did you intend to add NULL"") -test(1353.5, DT[2, `:=`(b=2, c=NULL)], error=""Invalid attempt to delete a list column.*did you intend to add NULL"") -test(1353.6, DT[2, d := NULL], error=""Doubly-invalid attempt to delete a non-existent column while also providing i"") - -# order optimisation caused trouble due to chaining because of 'substitute(x)' usage in [.data.table. -set.seed(1L) -X = data.table(id=1:10, val1=sample(3,10,TRUE)) -Y = data.table(val1=1:4, val2=8:5, key=""val1"") -setkey(X, val1) -test(1354, X[Y, val2 := i.val2, allow.cartesian=TRUE][, val1 := NULL][order(id)], data.table(id=1:10, val2=as.integer(c(8,7,7,6,8,6,6,7,7,8)))) - -# Fix for #475, setDT(CO2) should error, as it's trying to modify the object whose binding is locked. -# NB: requires datasets be attached -- no error thrown on datasets::CO2 or CO2=datasets::CO2 or get(""CO2"", asNamespace(""CO2"")) -test(1355, setDT(CO2), error=""Cannot convert 'CO2' to data.table by reference because binding is locked."") - ---- - -setkey = function(x, ..., verbose=getOption(""datatable.verbose""), physical=TRUE) -{ - if (is.character(x)) stopf(""x may no longer be the character name of the data.table. The possibility was undocumented and has been removed."") - cols = as.character(substitute(list(...))[-1L]) - if (!length(cols)) { cols=colnames(x) } - else if (identical(cols,""NULL"")) cols=NULL - setkeyv(x, cols, verbose=verbose, physical=physical) -} - -# FR #1442 -setindex = function(...) setkey(..., physical=FALSE) -setindexv = function(x, cols, verbose=getOption(""datatable.verbose"")) { - if (is.list(cols)) { - sapply(cols, setkeyv, x=x, verbose=verbose, physical=FALSE) - invisible(x) - } else { - setkeyv(x, cols, verbose=verbose, physical=FALSE) - } -} - -setkeyv = function(x, cols, verbose=getOption(""datatable.verbose""), physical=TRUE) -{ - if (is.null(cols)) { # this is done on a data.frame when !cedta at top of [.data.table - if (physical) setattr(x,""sorted"",NULL) - setattr(x,""index"",NULL) # setkey(DT,NULL) also clears secondary keys. setindex(DT,NULL) just clears secondary keys. - return(invisible(x)) - } - if (!missing(verbose)) { - stopifnot(isTRUEorFALSE(verbose)) - # set the global verbose option because that is fetched from C code without having to pass it through - oldverbose = options(datatable.verbose=verbose) - on.exit(options(oldverbose)) - } - if (!is.data.table(x)) stopf(""x is not a data.table"") - if (!is.character(cols)) stopf(""cols is not a character vector. Please see further information in ?%s."", ""setkey"") - if (physical && .Call(C_islocked, x)) stopf(""Setting a physical key on .SD is reserved for possible future use; to modify the original data's order by group. Try setindex() instead. Or, set*(copy(.SD)) as a (slow) last resort."") - if (!length(cols)) { - warningf(""cols is a character vector of zero length. Removed the key, but use NULL instead, or wrap with suppressWarnings() to avoid this warning."") - setattr(x,""sorted"",NULL) - return(invisible(x)) - } - if (identical(cols,"""")) stopf(""cols is the empty string. Use NULL to remove the key."") - if (!all(nzchar(cols))) stopf(""cols contains some blanks."") - cols = gsub(""`"", """", cols, fixed = TRUE) - miss = !(cols %chin% colnames(x)) - if (any(miss)) stopf(""some columns are not in the data.table: %s"", brackify(cols[miss]), class = ""dt_missing_column_error"") - - if (physical && identical(head(key(x), length(cols)), cols)){ ## for !physical we need to compute groups as well #4387 - ## key is present but x has a longer key. No sorting needed, only attribute is changed to shorter key. - setattr(x,""sorted"",cols) - return(invisible(x)) - } - - if ("".xi"" %chin% names(x)) stopf(""x contains a column called '.xi'. Conflicts with internal use by data.table."") - for (i in cols) { - .xi = x[[i]] # [[ is copy on write, otherwise checking type would be copying each column - if (!typeof(.xi) %chin% ORDERING_TYPES) stopf(""Column '%s' is type '%s' which is not supported as a key column type, currently."", i, typeof(.xi), class=""dt_unsortable_type_error"") - } - if (!is.character(cols) || length(cols)<1L) internal_error(""'cols' should be character at this point"") # nocov - ---- - -\name{tables} -\alias{tables} -\title{Display 'data.table' metadata } -\description{ - Convenience function for concisely summarizing some metadata of all \code{data.table}s in memory (or an optionally specified environment). -} -\usage{ -tables(mb=type_size, order.col=""NAME"", width=80, - env=parent.frame(), silent=FALSE, index=FALSE) -} -\arguments{ - \item{mb}{ a function which accepts a \code{data.table} and returns its size in bytes. By default, \code{type_size} (same as \code{TRUE}) provides a fast lower bound by excluding the size of character strings in R's global cache (which may be shared) and excluding the size of list column items (which also may be shared). A column \code{""MB""} is included in the output unless \code{FALSE} or \code{NULL}. } - \item{order.col}{ Column name (\code{character}) by which to sort the output. } - \item{width}{ \code{integer}; number of characters beyond which the output for each of the columns \code{COLS}, \code{KEY}, and \code{INDICES} are truncated. } - \item{env}{ An \code{environment}, typically the \code{.GlobalEnv} by default, see Details. } - \item{silent}{ \code{logical}; should the output be printed? } - \item{index}{ \code{logical}; if \code{TRUE}, the column \code{INDICES} is added to indicate the indices assorted with each object, see \code{\link{indices}}. } -} -\details{ -Usually \code{tables()} is executed at the prompt, where \code{parent.frame()} returns \code{.GlobalEnv}. \code{tables()} may also be useful inside functions where \code{parent.frame()} is the local scope of the function; in such a scenario, simply set it to \code{.GlobalEnv} to get the same behaviour as at prompt. - -\code{mb = utils::object.size} provides a higher and more accurate estimate of size, but may take longer. Its default \code{units=""b""} is appropriate. - -Setting \code{silent=TRUE} prints nothing; the metadata is returned as a \code{data.table} invisibly whether \code{silent} is \code{TRUE} or \code{FALSE}. -} -\value{ - A \code{data.table} containing the information printed. -} -\seealso{ \code{\link{data.table}}, \code{\link{setkey}}, \code{\link{ls}}, \code{\link{objects}}, \code{\link{object.size}} } -\examples{ -DT = data.table(A=1:10, B=letters[1:10]) -DT2 = data.table(A=1:10000, ColB=10000:1) -setkey(DT,B) -tables() -} -\keyword{ data } - ---- - -#: onAttach.R:26 -#, c-format -msgid ""Latest news: r-datatable.com"" -msgstr ""Últimas notícias: r-datatable.com"" - -#: onAttach.R:27 -msgid ""TRANSLATION CHECK"" -msgstr ""VERIFICAÇÃO DE TRADUÇÃO"" - -#: onAttach.R:29 -#, c-format -msgid """" -""**********\n"" -""Running data.table in English; package support is available in English only. "" -""When searching for online help, be sure to also check for the English error "" -""message. This can be obtained by looking at the po/R-.po and po/"" -"".po files in the package source, where the native language and "" -""English error messages can be found side-by-side.%s\n"" -""**********"" -msgstr """" -""**********\n"" -""Executando data.table em português; o suporte ao pacote está disponível "" -""apenas em inglês. Ao procurar ajuda online, certifique-se de verificar "" -""também a mensagem de erro em inglês. Isso pode ser obtido examinando os "" -""arquivos po/R-pt_BR.po e po/pt_BR.po no código-fonte do pacote, onde as "" -""mensagens de erro no idioma nativo e em inglês podem ser encontradas lado a "" -""lado.%s\n"" -""**********"" - -#: onAttach.R:30 -msgid """" -""You can also try calling Sys.setLanguage('en') prior to reproducing the "" -""error message."" -msgstr """" -""Você também pode tentar chamar Sys.setLanguage('en') antes de reproduzir a "" -""mensagem de erro."" - -#: onAttach.R:34 -#, c-format -msgid """" -""**********\n"" -""This development version of data.table was built more than 4 weeks ago. "" -""Please update: data.table::update_dev_pkg()\n"" -""**********"" -msgstr """" -""**********\n"" -""Esta versão de desenvolvimento do data.table foi construída há mais de 4 "" -""semanas. Por favor, atualize: data.table::update_dev_pkg()\n"" -""**********"" - -#: onAttach.R:36 -#, c-format -msgid """" -""**********\n"" -""This installation of data.table has not detected OpenMP support. It should "" -""still work but in single-threaded mode."" -msgstr """" -""**********\n"" -""Esta instalação do data.table não detectou suporte ao OpenMP. Ainda deve "" -""funcionar, mas em modo de single-threaded."" - -#: onAttach.R:38 -#, c-format -msgid """" -""This is a Mac. Please read https://mac.r-project.org/openmp/. Please engage "" -""with Apple and ask them for support. Check r-datatable.com for updates, and "" -""our Mac instructions here: https://github.com/Rdatatable/data.table/wiki/"" -""Installation. After several years of many reports of installation problems "" -""on Mac, it's time to gingerly point out that there have been no similar "" -""problems on Windows or Linux.\n"" -""**********"" -msgstr """" -""Este é um Mac. Por favor, leia https://mac.r-project.org/openmp/. Por favor, "" -""envolva-se com a Apple e peça suporte. Verifique r-datatable.com para "" -""atualizações e nossas instruções para Mac aqui: https://github.com/"" -""Rdatatable/data.table/wiki/Installation. Após vários anos de muitos relatos "" -""de problemas de instalação no Mac, é hora de apontar cuidadosamente que não "" -""houve problemas semelhantes no Windows ou Linux.\n"" -""**********"" - -#: onAttach.R:40 -#, c-format -msgid """" -""This is %s. This warning should not normally occur on Windows or Linux where "" -""OpenMP is turned on by data.table's configure script by passing -fopenmp to "" -""the compiler. If you see this warning on Windows or Linux, please file a "" -""GitHub issue.\n"" -""**********"" -msgstr """" -""Este é %s. Este aviso normalmente não deve ocorrer no Windows ou Linux, onde "" -""o OpenMP é ativado pelo script de configuração do data.table passando "" -""-fopenmp para o compilador. Se você vir este aviso no Windows ou Linux, por "" -""favor, relate no rastreador de problemas no GitHub.\n"" -""**********"" - -#: onLoad.R:5 -#, c-format -msgid """" -""Option 'datatable.nomatch' is defined but is now ignored. Please see note 11 "" -""in v1.12.4 NEWS (Oct 2019), and note 14 in v1.14.2."" -msgstr """" -""Opção 'datatable.nomatch' está definida, mas agora é ignorada. Por favor, "" -""veja a nota 11 nas notícias de v1.12.4 (Outubro de 2019) e a nota 14 em "" -""v1.14.2."" - ---- - -### g) ¿Por qué mantener `j` tan flexible? - -Para mantener una sintaxis consistente y seguir usando funciones base ya existentes (y conocidas), en lugar de tener que aprender nuevas funciones. Para ilustrar, usemos el `data.table` `DT` que creamos al principio, en la sección [¿Qué es un data.table?](#what-is-datatable-1a). - -#### -- ¿Cómo podemos concatenar las columnas `a` y `b` para cada grupo en `ID`? - -```{r} -DT[, .(val = c(a,b)), by = ID] -``` - -* Eso es todo. No se requiere sintaxis especial. Solo necesitamos saber la función base `c()`, que concatena vectores, y [la sugerencia anterior](#tip-1). - -#### --¿Qué sucede si queremos tener todos los valores de las columnas `a` y `b` concatenados, pero devueltos como una columna de lista? - -```{r} -DT[, .(val = list(c(a,b))), by = ID] -``` - -* Aquí, primero concatenamos los valores con `c(a,b)` para cada grupo y los envolvemos con `list()`. Por lo tanto, para cada grupo, devolvemos una lista de todos los valores concatenados. - -* Tenga en cuenta que estas comas son solo para visualización. Una columna de lista puede contener cualquier objeto en cada celda; en este ejemplo, cada celda es un vector, y algunas celdas contienen vectores más largos que otras. - -Una vez que empiece a internalizar el uso de `j`, se dará cuenta de lo poderosa que puede ser la sintaxis. Una forma muy útil de comprenderla es experimentando con la ayuda de `print()`. - -Por ejemplo: - -```{r} -## look at the difference between -DT[, print(c(a,b)), by = ID] # (1) - -## and -DT[, print(list(c(a,b))), by = ID] # (2) -``` - -```{r, echo = FALSE} -p = function(x) paste0('', paste(deparse(substitute(x)), collapse = ' '), ' = ', x, '') -``` - -En (1), para cada grupo, se devuelve un vector, con longitud = 6,4,2. Sin embargo, (2) devuelve una lista de longitud 1 para cada grupo, cuyo primer elemento contiene vectores de longitud 6,4,2. Por lo tanto, (1) da como resultado una longitud de `{r} p(6+4+2)`, mientras que (2) devuelve `{r} p(1+1+1)`. - -La flexibilidad de j nos permite almacenar cualquier objeto de lista como elemento de data.table. Por ejemplo, cuando los modelos estadísticos se ajustan a grupos, estos modelos pueden almacenarse en una tabla data.table. El código es conciso y fácil de entender. - -```{r} -## Do long distance flights cover up departure delay more than short distance flights? -## Does cover up vary by month? -flights[, `:=`(makeup = dep_delay - arr_delay)] - -makeup.models <- flights[, .(fit = list(lm(makeup ~ distance))), by = .(month)] -makeup.models[, .(coefdist = coef(fit[[1]])[2], rsq = summary(fit[[1]])$r.squared), by = .(month)] -``` - -Usando data.frames, necesitamos un código más complicado para obtener el mismo resultado. - -```{r} -setDF(flights) -flights.split <- split(flights, f = flights$month) -makeup.models.list <- lapply(flights.split, function(df) c(month = df$month[1], fit = list(lm(makeup ~ distance, data = df)))) -makeup.models.df <- do.call(rbind, makeup.models.list) -data.frame(t(sapply( - makeup.models.df[, ""fit""], - function(model) c(coefdist = coef(model)[2L], rsq = summary(model)$r.squared) -))) -setDT(flights) -``` - -## Resumen - -La forma general de la sintaxis de `data.table` es: - -```r -DT[i, j, by] -``` - -Hemos visto hasta ahora que, - -#### Usando `i`: - -* Podemos filtrar filas de manera similar a un `data.frame`, excepto que no es necesario usar `DT$` repetidamente, ya que las columnas dentro del marco de un `data.table` se ven como si fueran *variables*. - -* También podemos ordenar una `data.table` usando `order()`, que internamente usa el orden rápido de data.table para un mejor rendimiento. - -Podemos hacer mucho más en `i` al introducir claves en `data.table`, lo que permite filtrados y uniones ultrarrápidos. Veremos esto en las viñetas [`vignette(""datatable-keys-fast-subset"", package=""data.table"")`](datatable-keys-fast-subset.html) y [`vignette(""datatable-joins"", package=""data.table"")`](datatable-joins.html). - -#### Usando `j`: - ---- - -# Use existing index even when auto index is disabled #1422 -d = data.table(k=3:1) # subset - no index -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=TRUE) -test(1666.01, d[k==1L, verbose=TRUE], d[3L], output=""Creating new index 'k'"") -d = data.table(k=3:1) -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=FALSE) -test(1666.02, d[k==1L, verbose=TRUE], notOutput=""Creating new index"") # do not create index -d = data.table(k=3:1) -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=FALSE) -test(1666.03, d[k==1L, verbose=TRUE], notOutput=""Creating new index"") -d = data.table(k=3:1) -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=TRUE) -test(1666.04, d[k==1L, verbose=TRUE], notOutput=""Creating new index"") -d = data.table(k=3:1) # subset - index -setindex(d, k) -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=TRUE) -test(1666.05, d[k==1L, verbose=TRUE], d[3L], output=""Optimized subsetting with index 'k'"") -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=FALSE) -test(1666.06, d[k==1L, verbose=TRUE], d[3L], output=""Optimized subsetting with index 'k'"") -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=FALSE) -test(1666.07, d[k==1L, verbose=TRUE], notOutput=""Using existing index"") # not using existing index -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=TRUE) -test(1666.08, d[k==1L, verbose=TRUE], notOutput=""Using existing index"") -d1 = data.table(k=3:1) # join - no index -d2 = data.table(k=2:4) -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=TRUE) -test(1666.09, d1[d2, on=""k"", verbose=TRUE], d1[d2, on=""k""], output=""ad hoc"") -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=FALSE) -test(1666.10, d1[d2, on=""k"", verbose=TRUE], d1[d2, on=""k""], output=""ad hoc"") -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=FALSE) -test(1666.11, d1[d2, on=""k"", verbose=TRUE], notOutput=""Looking for existing (secondary) index"") # not looking for index -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=TRUE) -test(1666.12, d1[d2, on=""k"", verbose=TRUE], notOutput=""Looking for existing (secondary) index"") -d1 = data.table(k=3:1,v1=10:12) # join - index -d2 = data.table(k=2:4,v2=20:22) -setindex(d1, k) -ans = data.table(k=2:4, v1=c(11L,10L,NA), v2=20:22) -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=TRUE) -test(1666.13, d1[d2, on=""k"", verbose=TRUE], ans, output=""existing index"") -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=FALSE) -test(1666.14, d1[d2, on=""k"", verbose=TRUE], ans, output=""existing index"") -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=FALSE) -test(1666.15, d1[d2, on=""k"", verbose=TRUE], ans, output='ad hoc') -options(""datatable.use.index""=FALSE, ""datatable.auto.index""=TRUE) -test(1666.16, d1[d2, on=""k"", verbose=TRUE], ans, output='ad hoc') -# reset defaults -options(""datatable.use.index""=TRUE, ""datatable.auto.index""=TRUE) - -#testing fix to #1654 (dcast should only error when _using_ duplicated names) -DT <- data.table(a = 1:4, a = 1:4, id = rep(1:4, 2), V1 = 8:1) -test(1667.1, dcast(DT, id ~ rowid(id), value.var = ""V1""), - output = "" id 1 2\n1: 1 8 4\n2: 2 7 3\n3: 3 6 2\n4: 4 5 1"") -DT <- data.table(a = 1:4, id = 1:4, id = rep(1:4, 2), V1 = 8:1) -test(1667.2, dcast(DT, id ~ rowid(id), value.var = ""V1""), error = ""data.table to cast"") - -# fix for #1672 -test(1668, chmatch(c(""a"",""b""), c(""a"",""c""), nomatch = integer()), c(1L, NA_integer_)) - ---- - -/** - * This function is invoked by `freadMain` before the main scan of the input - * file. It should allocate the resulting `DataTable` structure and prepare - * to receive the data in chunks. - * - * Additionally, this function will be invoked if the main scan was - * unsuccessful. This may happen either because there were out-of-sample type - * exceptions (i.e. a value was found in one of the columns that wasn't - * acceptable for that column's type), or if the initial estimate of the file's - * number of rows turned out to be too conservative, and more rows has to be - * appended to the DataTable. - * - * @param types - * array of type codes for each column. Same as in the `userOverride` - * function. - * - * @param sizes - * the size (in bytes) of each column within the buffer(s) that will be - * passed to `pushBuffer()` during the scan. This array should be saved for - * later use. It exists mostly for convenience, since the size of each - * non-skipped column may be determined from that column's type. - * - * @param ncols - * number of columns in the CSV file. This is the size of arrays `types` and - * `sizes`. - * - * @param ndrop - * count of columns with type CT_DROP. This parameter is provided for - * convenience, since it can always be computed from `types`. The resulting - * datatable will have `ncols - ndrop` columns. - * - * @param nrows - * the number of rows to allocate for the datatable. This number of rows is - * estimated during the initial pre-scan, and then adjusted upwards to - * account for possible variation. It is very unlikely that this number - * underestimates the final row count. - * - * @return - * this function should return the total size of the Datatable created (for - * reporting purposes). If the return value is 0, then it indicates an error - * and `fread` will abort. - */ -size_t allocateDT(int8_t *types, int8_t *sizes, int ncols, int ndrop, - size_t nrows); - - -/** - * Called once at the beginning of each thread before it starts scanning the - * input file. If the file needs to be rescanned because of out-of-type - * exceptions, this will be called again before the second scan. - */ -void prepareThreadContext(ThreadLocalFreadParsingContext *ctx); - - -/** - * Give upstream the chance to modify the scanned buffers after the thread - * finished reading its chunk but before it enters the ""ordered"" section. - * Variable `ctx.DTi` is not available at this moment. - */ -void postprocessBuffer(ThreadLocalFreadParsingContext *ctx); - - -/** - * Callback invoked within the ""ordered"" section for each thread. Only - * lightweight processing should be performed here, since this section stalls - * execution of any other thread! - */ -void orderBuffer(ThreadLocalFreadParsingContext *ctx); - - -/** - * This function transfers the scanned input data into the final DataTable - * structure. It will be called many times, and from parallel threads (thus - * it should not attempt to modify any global variables). Its primary job is - * to transpose the data: convert from row-major order within each buffer - * into the column-major order for the resulting DataTable. - */ -void pushBuffer(ThreadLocalFreadParsingContext *ctx); - - -/** - * Called at the end to specify what the actual number of rows in the datatable - * was. The function should adjust the datatable, reallocing the buffers if - * necessary. - * If the input file needs to be rescanned due to some columns having wrong - * column types, then this function will be called once after the file is - * finished scanning but before any calls to `reallocColType()`, and then the - * second time after the entire input file was scanned again. - */ -void setFinalNrow(size_t nrows); - - -/** - * Called at the end to delete columns added due to too high user guess for fill. - */ -void dropFilledCols(int* dropArg, int ndrop); - -/** - * Free any srtuctures associated with the thread-local parsing context. - */ -void freeThreadContext(ThreadLocalFreadParsingContext *ctx); - ---- - -#: data.table.R:448 -#, c-format -msgid """" -""i is invalid type (matrix). Perhaps in future a 2 column matrix could return "" -""a list of elements of DT (in the spirit of A[B] in FAQ 2.14). Please report "" -""to data.table issue tracker if you'd like this, or add your comments to FR "" -""#657."" -msgstr """" -""i不是一个有效的类型(矩阵)。也许在以后一个包含两列的矩阵会返回包含一串元素的"" -""DT (请参考问答集2.14的A[B])。如果你有需求，请将此问题汇报给data.table 问题追"" -""踪器或者是在FR中留下你的想法"" - -#: data.table.R:471 -#, fuzzy, c-format -#| msgid """" -#| ""When i is a data.table (or character vector), the columns to join by must "" -#| ""be specified using 'on=' argument (see ?data.table), by keying x (i.e. "" -#| ""sorted, and, marked as sorted, see ?setkey), or by sharing column names "" -#| ""between x and i (i.e., a natural join). Keyed joins might have further "" -#| ""speed benefits on very large data due to x being sorted in RAM."" -msgid """" -""When i is a data.table (or character vector), the columns to join by must be "" -""specified using the 'on=' argument (see ?data.table); by keying x (i.e., x "" -""is sorted and marked as such, see ?setkey); or by using 'on = .NATURAL' to "" -""indicate using the shared column names between x and i (i.e., a natural "" -""join). Keyed joins might have further speed benefits on very large data due "" -""to x being sorted in RAM."" -msgstr """" -""但i是一个 data.table (或者是字符向量)，必须使用 'on=' 参数指明参与连接的列 "" -""(参见 ?data.table)，可以是keying x(比如，已排序过，和标记已排序过，请参见?"" -""setkey)，或者是在x和i共用列的名字(比如，自然连接)。如果x有在内存被排序过，键"" -""(keyed)连接的速度会在非常大的数据上有较明显的提高。"" - -#: data.table.R:479 -#, c-format -msgid ""Attempting to do natural join but no common columns in provided tables"" -msgstr ""尝试进行自然连接然而并没有找到表格中相同的列"" - -#: data.table.R:482 -msgid ""Joining but 'x' has no key, natural join using all 'x' columns"" -msgstr """" - -#: data.table.R:484 -msgid ""Joining but 'x' has no key, natural join using: %s"" -msgstr """" - -#: data.table.R:513 -msgid ""not-join called with 'by=.EACHI'; Replacing !i with i=setdiff_(x,i) ..."" -msgstr """" - -#: data.table.R:544 -msgid ""Constructing irows for '!byjoin || nqbyjoin' ..."" -msgstr """" - -#: data.table.R:558 mergelist.R:124 -#, c-format -msgid """" -""Joining resulted in many-to-many join. Perform quality check on your data, "" -""use mult!='all', or set 'datatable.join.many' option to TRUE to allow rows "" -""explosion."" -msgstr """" - -#: data.table.R:596 -msgid ""Reorder irows for 'mult==\""all\"" && !allGrp1' ..."" -msgstr """" - -#: data.table.R:608 -msgid ""Reordering %d rows after bmerge done in ..."" -msgstr """" - -#: data.table.R:625 -#, c-format -msgid ""logical error. i is not a data.table, but 'on' argument is provided."" -msgstr ""逻辑错误。当 i 并非一个 data.table时，不应提供'on'参数"" - -#: data.table.R:629 -#, c-format -msgid ""i has evaluated to type %s. Expecting logical, integer or double."" -msgstr ""经计算 i 为 %s 类型。需要布尔类型，整型或浮点型。"" - -#: data.table.R:651 -#, c-format -msgid """" -""i evaluates to a logical vector length %d but there are %d rows. Recycling "" -""of logical i is no longer allowed as it hides more bugs than is worth the "" -""rare convenience. Explicitly use rep(...,length=.N) if you really need to "" -""recycle."" -msgstr """" -""经计算 i 为长度为 %d 的逻辑向量，但数据框有 %d 行。循环补齐循环补齐逻辑向量 "" -""i 的特性虽然在少数情况下使用方便，但这种行为会隐藏更多的 bug，因此现已不被允"" -""许。若确实需要循环补齐，请直接使用 rep(...,length=.N)。"" - -#: data.table.R:654 -#, c-format -msgid """" -""Please use nomatch=NULL instead of nomatch=0; see news item 5 in v1.12.0 "" -""(Jan 2019)"" -msgstr """" -""请使用 nomatch=NULL 而非 nomatch=0；参见 v1.12.0 (2019年1月) 中更新条目 5"" - -#: data.table.R:669 -msgid ""Inverting irows for notjoin done in ..."" -msgstr """" - -#: data.table.R:725 -#, c-format -msgid ""`:=` is only supported under with=TRUE, see ?`:=`."" -msgstr """" - -#: data.table.R:767 -#, c-format -msgid ""Item %d of j is %d which is outside the column number range [1,ncol=%d]"" -msgstr ""j 中的第 %d 项的数值为 %d，已超出列索引的范围内1,ncol=%d]"" - -#: data.table.R:770 -#, c-format -msgid ""j mixes positives and negatives"" -msgstr ""j 中同时存在正数和负数"" - -#: data.table.R:778 -#, c-format -msgid """" -""When with=FALSE, j-argument should be of type logical/character/integer "" -""indicating the columns to select."" -msgstr ""当 with=FALSE，参数 j 必须为布尔型/字符型/整型之一，表征要选择的列。"" - ---- - -test(6001.211, frollsum(1:3, 0), c(0,0,0), options=c(""datatable.verbose""=TRUE), output=""window width of size 0"") -test(6001.212, frollsum(1:3, 0, fill=99), c(0,0,0)) -test(6001.213, frollsum(c(1:2,NA), 0), c(0,0,0)) -test(6001.214, frollsum(c(1:2,NA), 0, na.rm=TRUE), c(0,0,0)) -test(6001.215, frollsum(1:3, 0, algo=""exact""), c(0,0,0), options=c(""datatable.verbose""=TRUE), output=""window width of size 0"") -test(6001.216, frollsum(c(1:2,NA), 0, algo=""exact""), c(0,0,0)) -test(6001.217, frollsum(c(1:2,NA), 0, algo=""exact"", na.rm=TRUE), c(0,0,0)) -test(6001.221, frollsum(adaptive=TRUE, 1:3, c(2,0,2)), c(NA,0,5)) -test(6001.222, frollsum(adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,0,5)) -test(6001.223, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,0,NA)) -test(6001.224, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,0,2)) -test(6001.225, frollsum(adaptive=TRUE, 1:3, c(2,0,2), algo=""exact""), c(NA,0,5)) -test(6001.226, frollsum(adaptive=TRUE, 1:3, c(2,0,2), fill=99, algo=""exact""), c(99,0,5)) -test(6001.227, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact""), c(NA,0,NA)) -test(6001.228, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact"", na.rm=TRUE), c(NA,0,2)) -test(6001.229, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact"", na.rm=TRUE, partial=TRUE), c(1,0,2)) -test(6001.230, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), fill=99, algo=""exact"", na.rm=TRUE), c(99,0,2)) -test(6001.281, frollapply(FUN=sum, as.numeric(1:3), 0), c(0,0,0)) -test(6001.282, frollapply(FUN=sum, as.numeric(1:3), 0, fill=99), c(0,0,0)) -test(6001.283, frollapply(FUN=sum, c(1:2,NA_real_), 0), c(0,0,0)) -test(6001.284, frollapply(FUN=sum, c(1:2,NA_real_), 0, na.rm=TRUE), c(0,0,0)) -test(6001.285, frollapply(FUN=sum, c(FALSE, TRUE, TRUE), 0), c(0L,0L,0L)) -test(6001.286, frollapply(FUN=sum, 1:3, 0), c(0L,0L,0L)) -test(6001.2910, frollapply(FUN=sum, adaptive=TRUE, as.numeric(1:3), c(2,0,2)), c(NA,0,5)) -test(6001.2911, frollapply(FUN=sum, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), c(2,0,2)), list(c(NA,0,5), c(NA,0,7))) -test(6001.2912, frollapply(FUN=sum, adaptive=TRUE, as.numeric(1:3), list(c(2,0,2), c(0,2,0))), list(c(NA,0,5), c(0,3,0))) -test(6001.2913, frollapply(FUN=sum, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), list(c(2,0,2), c(0,2,0))), list(c(NA,0,5), c(0,3,0), c(NA,0,7), c(0,5,0))) -test(6001.2914, frollapply(FUN=sum, adaptive=TRUE, c(FALSE, TRUE, TRUE), c(2,0,2)), c(NA,0L,2L)) -test(6001.2915, frollapply(FUN=sum, adaptive=TRUE, 1:3, c(2,0,2)), c(NA,0L,5L)) -test(6001.292, frollapply(FUN=sum, adaptive=TRUE, as.numeric(1:3), c(2,0,2), fill=99), c(99,0,5)) -test(6001.293, frollapply(FUN=sum, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2)), c(NA,0,NA)) -test(6001.294, frollapply(FUN=sum, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE), c(NA,0,2)) -test(6001.295, frollapply(FUN=sum, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE, partial=TRUE), c(1,0,2)) -test(6001.296, frollapply(FUN=sum, adaptive=TRUE, c(FALSE, TRUE, TRUE), c(2,0,2), fill=1L), c(1L,0L,2L)) -test(6001.297, frollapply(FUN=sum, adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99L,0L,5L)) - ---- - -35. `as.data.table.*(x, keep.rownames=TRUE)`, where `x` is a named vector now adds names of `x` into a new column with default name `rn`. Thanks to Garrett See for FR #2356. - - 36. `X[Y, col:=value]` when no match exists in the join is now caught early and X is simply returned. Also a message when `datatable.verbose` is TRUE is provided. In addition, if `col` is an existing column, since no update actually takes place, the key is now retained. Thanks to Frank Erickson for suggesting, #4996. - - 37. New function `setDT()` takes a `list` (named and/or unnamed) or `data.frame` and changes its type by reference to `data.table`, *without any copy*. It also has a logical argument `giveNames` which is used for a list inputs. See `?setDT` examples for more. Based on [this FR on SO](https://stackoverflow.com/questions/20345022/convert-a-data-frame-to-a-data-table-without-copy/20346697#20346697). - - 38. `setnames(DT,""oldname"",""newname"")` no longer complains about any duplicated column names in `DT` so long as oldname is unique and unambiguous. Thanks to Wet Feet for highlighting [here on SO](https://stackoverflow.com/questions/20942905/ignore-safety-check-when-using-setnames). - - 39. `last(x)` where `length(x)=0` now returns 'x' instead of an error, #5152. Thanks to Garrett See for reporting. - - 40. `as.ITime.character` no longer complains when given vector input, and will accept mixed format time entries; e.g., c(""12:00"", ""13:12:25"") - - 41. Key is now retained in `NA` subsets; e.g., - ```R - DT = data.table(a=1:3,b=4:6,key=""a"") - DT[NA] # 1-row of NA now keyed by 'a' - DT[5] # 1-row of NA now keyed by 'a' - DT[2:4] # not keyed as before because NA (last row of result) sorts first in keyed data.table - ``` - - 42. Each column in the result for each group has always been recycled (if necessary) to match the longest column in that group's result. If it doesn't recycle exactly, though, it was caught gracefully as an error. Now, it is recycled, with remainder with warning. - ```R - DT = data.table(a=1:2,b=1:6) - DT[, list(b,1:2), by=a] # now recycles the 1:2 with warning to length 3 - ``` - -### BUG FIXES - - 1. Long outstanding (usually small) memory leak in grouping fixed, #2648. When the last group is smaller than the largest group, the difference in those sizes was not being released. Also evident in non-trivial aggregations where each group returns a different number of rows. Most users run a grouping - query once and will never have noticed these, but anyone looping calls to grouping (such as when running in parallel, or benchmarking) may have suffered. Tests added. Thanks to many including vc273 and Y T for reporting [here](https://stackoverflow.com/questions/20349159/memory-leak-in-data-table-grouped-assignment-by-reference) and [here](https://stackoverflow.com/questions/15651515/slow-memory-leak-in-data-table-when-returning-named-lists-in-j-trying-to-reshap) on SO. - - 2. In long running computations where data.table is called many times repetitively the following error could sometimes occur, #2647: *""Internal error: .internal.selfref prot is not itself an extptr""*. Now fixed. Thanks to theEricStone, StevieP and JasonB for (difficult) reproducible examples [here](https://stackoverflow.com/questions/15342227/getting-a-random-internal-selfref-error-in-data-table-for-r). - - 3. If `fread` returns a data error (such as no closing quote on a quoted field) it now closes the file first rather than holding a lock open, a Windows only problem. - Thanks to nigmastar for reporting [here](https://stackoverflow.com/questions/18597123/fread-data-table-locks-files) and Carl Witthoft for the hint. Tests added. - - 4. `DT[0,col:=value]` is now a helpful error rather than crash, #2754. Thanks to Ricardo Saporta for reporting. `DT[NA,col:=value]`'s error message has also been improved. Tests added. - ---- - -\item Expressions of the form \code{DT[i, j, by]} are also optimised when - \code{i} is a \emph{subset} operation and \code{j} is any/all of the functions - discussed above. -} - -For \code{getOption(""datatable.optimize"") >= 3}, additional optimisations for subsets in i are implemented on top of the optimisations already shown above. Subsetting operations are - if possible - translated into joins to make use of blazing fast binary search using indices and keys. The following queries are optimized: - -\itemize{ - - \item Supported operators: \code{==}, \code{\%in\%}. Non-equi operators(>, <, etc.) are not supported yet because non-equi joins are slower than vector based subsets. - \item Queries on multiple columns are supported, if the connector is '\code{&}', e.g. \code{DT[x == 2 & y == 3]} is supported, but \code{DT[x == 2 | y == 3]} is not. - \item Optimization will currently be turned off when doing subset when cross product of elements provided to filter on exceeds > 1e4. This most likely happens if multiple \code{\%in\%}, or \code{\%chin\%} queries are combined, e.g. \code{DT[x \%in\% 1:100 & y \%in\% 1:200]} will not be optimized since \code{100 * 200 = 2e4 > 1e4}. - \item Queries with multiple criteria on one column are \emph{not} supported, e.g. \code{DT[x == 2 & x \%in\% c(2,5)]} is not supported. - \item Queries with non-missing j are supported, e.g. \code{DT[x == 3 & y == 5, .(new = x-y)]} or \code{DT[x == 3 & y == 5, new := x-y]} are supported. Also extends to queries using \code{with = FALSE}. - \item ""notjoin"" queries, i.e. queries that start with \code{!}, are only supported if there are no \code{&} connections, e.g. \code{DT[!x==3]} is supported, but \code{DT[!x==3 & y == 4]} is not. -} - -If in doubt, whether your query benefits from optimization, call it with the \code{verbose = TRUE} argument. You should see ""Optimized subsetting\ldots"". - -\bold{Auto indexing:} In case a query is optimized, but no appropriate key or index is found, \code{data.table} automatically creates an \emph{index} on the first run. Any successive subsets on the same -column then reuse this index to \emph{binary search} (instead of -\emph{vector scan}) and is therefore fast. -Auto indexing can be switched off with the global option -\code{options(datatable.auto.index = FALSE)}. To switch off using existing -indices set global option \code{options(datatable.use.index = FALSE)}. -} -\seealso{ \code{\link{setNumericRounding}}, \code{\link{getNumericRounding}} } -\examples{ -\dontrun{ -old = options(datatable.optimize = Inf) - -# Generate a big data.table with a relatively many columns -set.seed(1L) -DT = lapply(1:20, function(x) sample(c(-100:100), 5e6L, TRUE)) -setDT(DT)[, id := sample(1e5, 5e6, TRUE)] -print(object.size(DT), units=""MiB"") # 400MiB, not huge, but will do - -# 'order' optimisation -options(datatable.optimize = 1L) # optimisation 'on' -system.time(ans1 <- DT[order(id)]) -options(datatable.optimize = 0L) # optimisation 'off' -system.time(ans2 <- DT[order(id)]) -identical(ans1, ans2) - -# optimisation of 'lapply(.SD, fun)' -options(datatable.optimize = 1L) # optimisation 'on' -system.time(ans1 <- DT[, lapply(.SD, min), by=id]) -options(datatable.optimize = 0L) # optimisation 'off' -system.time(ans2 <- DT[, lapply(.SD, min), by=id]) -identical(ans1, ans2) - -# optimisation of 'mean' -options(datatable.optimize = 1L) # optimisation 'on' -system.time(ans1 <- DT[, lapply(.SD, mean), by=id]) -system.time(ans2 <- DT[, lapply(.SD, base::mean), by=id]) -identical(ans1, ans2) - -# optimisation of 'c(.N, lapply(.SD, ))' -options(datatable.optimize = 1L) # optimisation 'on' -system.time(ans1 <- DT[, c(.N, lapply(.SD, min)), by=id]) -options(datatable.optimize = 0L) # optimisation 'off' -system.time(ans2 <- DT[, c(N=.N, lapply(.SD, min)), by=id]) -identical(ans1, ans2) - ---- - -#include ""data.table.h"" -#include -#include // for isdigit - ---- - -test(6001.411, frollmin(1:3, 0), c(Inf,Inf,Inf), options=c(""datatable.verbose""=TRUE), output=""window width of size 0"") -test(6001.412, frollmin(1:3, 0, fill=99), c(Inf,Inf,Inf)) -test(6001.413, frollmin(c(1:2,NA), 0), c(Inf,Inf,Inf)) -test(6001.414, frollmin(c(1:2,NA), 0, na.rm=TRUE), c(Inf,Inf,Inf)) -test(6001.415, frollmin(1:3, 0, algo=""exact""), c(Inf,Inf,Inf), options=c(""datatable.verbose""=TRUE), output=""window width of size 0"") -test(6001.416, frollmin(c(1:2,NA), 0, algo=""exact""), c(Inf,Inf,Inf)) -test(6001.417, frollmin(c(1:2,NA), 0, algo=""exact"", na.rm=TRUE), c(Inf,Inf,Inf)) -test(6001.421, frollmin(adaptive=TRUE, 1:3, c(2,0,2)), c(NA,Inf,2)) -test(6001.422, frollmin(adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,Inf,2)) -test(6001.423, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,Inf,NA)) -test(6001.424, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,Inf,2)) -test(6001.425, frollmin(adaptive=TRUE, 1:3, c(2,0,2), algo=""exact""), c(NA,Inf,2)) -test(6001.426, frollmin(adaptive=TRUE, 1:3, c(2,0,2), fill=99, algo=""exact""), c(99,Inf,2)) -test(6001.427, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact""), c(NA,Inf,NA)) -test(6001.428, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact"", na.rm=TRUE), c(NA,Inf,2)) -test(6001.429, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact"", na.rm=TRUE, partial=TRUE), c(1,Inf,2)) -test(6001.430, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), fill=99, algo=""exact"", na.rm=TRUE), c(99,Inf,2)) -test(6001.481, frollapply(FUN=min, 1:3, 0), c(Inf,Inf,Inf)) -test(6001.482, frollapply(FUN=min, 1:3, 0, fill=99), c(Inf,Inf,Inf)) -test(6001.483, frollapply(FUN=min, c(1:2,NA_real_), 0), c(Inf,Inf,Inf)) -test(6001.484, frollapply(FUN=min, c(1:2,NA_real_), 0, na.rm=TRUE), c(Inf,Inf,Inf)) -test(6001.4910, frollapply(FUN=min, adaptive=TRUE, as.numeric(1:3), c(2,0,2)), c(NA,Inf,2)) -test(6001.4911, frollapply(FUN=min, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), c(2,0,2)), list(c(NA,Inf,2), c(NA,Inf,3))) -test(6001.4912, frollapply(FUN=min, adaptive=TRUE, as.numeric(1:3), list(c(2,0,2), c(0,2,0))), list(c(NA,Inf,2), c(Inf,1,Inf))) -test(6001.4913, frollapply(FUN=min, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), list(c(2,0,2), c(0,2,0))), list(c(NA,Inf,2), c(Inf,1,Inf), c(NA,Inf,3), c(Inf,2,Inf))) -test(6001.492, frollapply(FUN=min, adaptive=TRUE, as.numeric(1:3), c(2,0,2), fill=99), c(99,Inf,2)) -test(6001.493, frollapply(FUN=min, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2)), c(NA,Inf,NA)) -test(6001.494, frollapply(FUN=min, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE), c(NA,Inf,2)) -test(6001.495, frollapply(FUN=min, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE, partial=TRUE), c(1,Inf,2)) - ---- - -test(6001.611, frollmedian(1:3, 0), c(NA_real_,NA_real_,NA_real_), options=c(""datatable.verbose""=TRUE), output=""window width of size 0"") -test(6001.612, frollmedian(1:3, 0, fill=99), c(NA_real_,NA_real_,NA_real_)) -test(6001.613, frollmedian(c(1:2,NA), 0), c(NA_real_,NA_real_,NA_real_)) -test(6001.614, frollmedian(c(1:2,NA), 0, na.rm=TRUE), c(NA_real_,NA_real_,NA_real_)) -test(6001.615, frollmedian(1:3, 0, algo=""exact""), c(NA_real_,NA_real_,NA_real_), options=c(""datatable.verbose""=TRUE), output=""window width of size 0"") -test(6001.616, frollmedian(c(1:2,NA), 0, algo=""exact""), c(NA_real_,NA_real_,NA_real_)) -test(6001.617, frollmedian(c(1:2,NA), 0, algo=""exact"", na.rm=TRUE), c(NA_real_,NA_real_,NA_real_)) -test(6001.621, frollmedian(adaptive=TRUE, 1:3, c(2,0,2)), c(NA,NA_real_,2.5)) -test(6001.6211, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), has.nf=TRUE), c(NA,NA_real_,2.5), options=c(""datatable.verbose""=TRUE), output=""no NAs detected, redirecting to itself using"") -test(6001.6212, frollmedian(adaptive=TRUE, 1:3, c(0,0,0)), c(NA_real_,NA_real_,NA_real_), options=c(""datatable.verbose""=TRUE), output=""adaptive window width of size 0"") -test(6001.622, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,NA_real_,2.5)) -test(6001.623, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,NA_real_,NA)) -test(6001.624, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,NA_real_,2)) -test(6001.625, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), algo=""exact""), c(NA,NA_real_,2.5)) -test(6001.626, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), fill=99, algo=""exact""), c(99,NA_real_,2.5)) -test(6001.627, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact""), c(NA,NA_real_,NA)) -test(6001.628, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact"", na.rm=TRUE), c(NA,NA_real_,2)) -test(6001.629, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=""exact"", na.rm=TRUE, partial=TRUE), c(1,NA_real_,2)) -test(6001.630, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), fill=99, algo=""exact"", na.rm=TRUE), c(99,NA_real_,2)) -test(6001.681, frollapply(FUN=median, c(1,2,3), 0), c(NA_real_,NA_real_,NA_real_)) -test(6001.6811, frollapply(FUN=median, 1:3, 0), c(NA_integer_,NA_integer_,NA_integer_)) -test(6001.682, frollapply(FUN=median, c(1,2,3), 0, fill=99), c(NA_real_,NA_real_,NA_real_)) -test(6001.683, frollapply(FUN=median, c(1,2,NA), 0), c(NA_real_,NA_real_,NA_real_)) -test(6001.684, frollapply(FUN=median, c(1,2,NA), 0, na.rm=TRUE), c(NA_real_,NA_real_,NA_real_)) -test(6001.6910, frollapply(FUN=median, adaptive=TRUE, c(1,2,3), c(2,0,2)), c(NA,NA_real_,2.5)) -test(6001.6911, frollapply(FUN=median, adaptive=TRUE, list(c(1,2,3),c(2,3,4)), c(2,0,2)), list(c(NA, NA_real_, 2.5), c(NA, NA_real_, 3.5))) -test(6001.6912, frollapply(FUN=median, adaptive=TRUE, c(1,2,3), list(c(2,0,2), c(0,2,0))), list(c(NA,NA_real_,2.5), c(NA_real_,1.5,NA_real_))) -test(6001.6913, frollapply(FUN=median, adaptive=TRUE, list(1:3,2:4), list(c(2,0,2), c(0,2,0))), list(c(NA,NA_real_,2.5), c(NA_real_,1.5,NA_real_), c(NA,NA_real_,3.5), c(NA_real_,2.5,NA_real_))) ## simplifylist -test(6001.692, frollapply(FUN=median, adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,NA_real_,2.5)) ## simplifylist -test(6001.6921, frollapply(FUN=median, adaptive=TRUE, c(1L,2L,4L), c(2,0,2), fill=99L), c(99,NA_real_,3)) ## fill coerced to results type -test(6001.6922, frollapply(FUN=median, adaptive=TRUE, c(1L,2L,3L), c(2,0,2), fill=99), c(99,NA_real_,2.5)) ## simplifylist handle non-type stable output for median(1:3) median(1:2) -test(6001.693, frollapply(FUN=median, adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,NA_integer_,NA)) -test(6001.694, frollapply(FUN=median, adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,NA_integer_,2L)) -test(6001.695, frollapply(FUN=median, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE, partial=TRUE), c(1,NA_real_,2)) - ---- - -selfrefok = function(DT,verbose=getOption(""datatable.verbose"")) { - .Call(Cselfrefokwrapper,DT,verbose) -} - -truelength = function(x) .Call(Ctruelength,x) -# deliberately no ""truelength<-"" method. setalloccol is the mechanism for that. -# settruelength() no longer need (and so removed) now that data.table depends on R 2.14.0 -# which initializes tl to zero rather than leaving uninitialized. - -setattr = function(x,name,value) { - # Wrapper for setAttrib internal R function - # Sets attribute by reference (no copy) - # Named setattr (rather than setattrib) at R level to more closely resemble attr<- - # And as from 1.7.8 is made exported in NAMESPACE for use in user attributes. - # User can also call `attr<-` function directly, but that copies (maybe just when NAMED>0, which is always for data.frame, I think). See ""Confused by NAMED"" thread on r-devel 24 Nov 2011. - # We tend to use setattr() internally in data.table.R because often we construct a data.table and it hasn't - # got names yet. setnames() is the user interface which checks integrity and doesn't let you drop names for example. - if (name==""names"" && is.data.table(x) && length(attr(x, ""names"", exact=TRUE)) && !is.null(value)) - setnames(x,value) - # Using setnames here so that truelength of names can be retained, to carry out integrity checks such as not - # creating names longer than the number of columns of x, and to change the key, too - # For convenience so that setattr(DT,""names"",allnames) works as expected without requiring a switch to setnames. - else { - ans = .Call(Csetattrib, x, name, value) - # If name==""names"" and this is the first time names are assigned (e.g. in data.table()), this will be grown by setalloccol very shortly afterwards in the caller. - if (!is.null(ans)) { - warningf(""Input is a length=1 logical that points to the same address as R's global value. Therefore the attribute has not been set by reference, rather on a copy. You will need to assign the result back to a variable. See issue #1281."") - x = ans - } - } - # fix for #1142 - duplicated levels for factors - if (name == ""levels"" && is.factor(x) && anyDuplicated(value)) - .Call(Csetlevels, x, (value <- as.character(value)), unique(value)) - invisible(x) -} - ---- - -x = 1:6/2 -test(6004.031, frollmedian(x, 3), c(NA,NA,1,1.5,2,2.5)) -test(6004.032, frollmedian(x, c(2L, 2L, 3L, 4L, 2L, 3L), adaptive=TRUE), c(NA, 0.75, 1, 1.25, 2.25, 2.5)) -options(datatable.verbose=TRUE) -test(6004.033, frollmedian(1:3, 2), c(NA, 1.5, 2.5), output=""frollmedianFast: running for input length"") -test(6004.034, frollmedian(1:3, c(2,2,2), adaptive=TRUE), c(NA, 1.5, 2.5), output=""frolladaptivemedianExact: running in parallel"") -options(datatable.verbose=FALSE) -test(6004.035, frollmedian(rep(NA_real_, 9), 3), rep(NA_real_, 9)) -test(6004.036, frollmedian(rep(NA_real_, 10), 3), rep(NA_real_, 10)) -test(6004.037, frollmedian(rep(NA_real_, 10), 4), rep(NA_real_, 10)) -test(6004.038, frollmedian(rep(NA_real_, 12), 4), rep(NA_real_, 12)) -d = as.data.table(list(1:6/2, 3:8/4)) -test(6004.039, frollmedian(d, 3:4), list(c(NA, NA, 1, 1.5, 2, 2.5), c(NA, NA, NA, 1.25, 1.75, 2.25), c(NA, NA, 1, 1.25, 1.5, 1.75), c(NA, NA, NA, 1.125, 1.375, 1.625))) - -x = c(1,2,3,4,NA,6) -k = 3 -test(6004.101, frollmedian(x, k, na.rm=FALSE), c(NA, NA, 2, 3, NA, NA)) -test(6004.102, frollmedian(x, k, na.rm=TRUE), c(NA, NA, 2, 3, 3.5, 5)) -test(6004.103, frollmedian(x, k, na.rm=FALSE, algo=""exact""), c(NA, NA, 2, 3, NA, NA)) -test(6004.104, frollmedian(x, k, na.rm=TRUE, algo=""exact""), c(NA, NA, 2, 3, 3.5, 5)) -x = c(1,2,3,4,NA,NA,6) -k = 3 -test(6004.105, frollmedian(x, k, na.rm=FALSE), c(NA, NA, 2, 3, NA, NA, NA)) -test(6004.106, frollmedian(x, k, na.rm=TRUE), c(NA, NA, 2, 3, 3.5, 4, 6)) -test(6004.107, frollmedian(x, k, na.rm=FALSE, algo=""exact""), c(NA, NA, 2, 3, NA, NA, NA)) -test(6004.108, frollmedian(x, k, na.rm=TRUE, algo=""exact""), c(NA, NA, 2, 3, 3.5, 4, 6)) -x = c(1,2,3,4,NA,6) -k = 4 -test(6004.109, frollmedian(x, k, na.rm=FALSE), c(NA, NA, NA, 2.5, NA, NA)) -test(6004.110, frollmedian(x, k, na.rm=TRUE), c(NA, NA, NA, 2.5, 3, 4)) -test(6004.111, frollmedian(x, k, na.rm=FALSE, algo=""exact""), c(NA, NA, NA, 2.5, NA, NA)) -test(6004.112, frollmedian(x, k, na.rm=TRUE, algo=""exact""), c(NA, NA, NA, 2.5, 3, 4)) -x = c(1,2,3,4,NA,NA,6) -k = 4 -test(6004.113, frollmedian(x, k, na.rm=FALSE), c(NA, NA, NA, 2.5, NA, NA, NA)) -test(6004.114, frollmedian(x, k, na.rm=TRUE), c(NA, NA, NA, 2.5, 3, 3.5, 5)) -test(6004.115, frollmedian(x, k, na.rm=FALSE, algo=""exact""), c(NA, NA, NA, 2.5, NA, NA, NA)) -test(6004.116, frollmedian(x, k, na.rm=TRUE, algo=""exact""), c(NA, NA, NA, 2.5, 3, 3.5, 5)) -x = c(1,2,3,4,NA,NA,NA,NA,6) -k = 3 -test(6004.117, frollmedian(x, k, na.rm=FALSE), c(NA, NA, 2, 3, NA, NA, NA, NA, NA)) -test(6004.118, frollmedian(x, k, na.rm=TRUE), c(NA, NA, 2, 3, 3.5, 4, NA, NA, 6)) -test(6004.119, frollmedian(x, k, na.rm=FALSE, algo=""exact""), c(NA, NA, 2, 3, NA, NA, NA, NA, NA)) -test(6004.120, frollmedian(x, k, na.rm=TRUE, algo=""exact""), c(NA, NA, 2, 3, 3.5, 4, NA, NA, 6)) -k = 4 -test(6004.121, frollmedian(x, k, na.rm=FALSE), c(NA, NA, NA, 2.5, NA, NA, NA, NA, NA)) -test(6004.122, frollmedian(x, k, na.rm=TRUE), c(NA, NA, NA, 2.5, 3, 3.5, 4, NA, 6)) -test(6004.123, frollmedian(x, k, na.rm=FALSE, algo=""exact""), c(NA, NA, NA, 2.5, NA, NA, NA, NA, NA)) -test(6004.124, frollmedian(x, k, na.rm=TRUE, algo=""exact""), c(NA, NA, NA, 2.5, 3, 3.5, 4, NA, 6)) -x = rep(NA_real_,10) -k = 3 -test(6004.125, frollmedian(x, k, na.rm=FALSE), rep(NA_real_,10)) -test(6004.126, frollmedian(x, k, na.rm=TRUE), rep(NA_real_,10)) -test(6004.127, frollmedian(x, k, na.rm=FALSE, algo=""exact""), rep(NA_real_,10)) -test(6004.128, frollmedian(x, k, na.rm=TRUE, algo=""exact""), rep(NA_real_,10)) -k = 4 -test(6004.129, frollmedian(x, k, na.rm=FALSE), rep(NA_real_,10)) -test(6004.130, frollmedian(x, k, na.rm=TRUE), rep(NA_real_,10)) -test(6004.131, frollmedian(x, k, na.rm=FALSE, algo=""exact""), rep(NA_real_,10)) -test(6004.132, frollmedian(x, k, na.rm=TRUE, algo=""exact""), rep(NA_real_,10)) - ---- - -### NOTES - -1. `rbindlist`'s `use.names=""check""` now emits its message for automatic column names (`""V[0-9]+""`) too, [#3484](https://github.com/Rdatatable/data.table/pull/3484). See news item 5 of v1.12.2 below. - -2. Adding a new column by reference using `set()` on a `data.table` loaded from binary file now give a more helpful error message, [#2996](https://github.com/Rdatatable/data.table/issues/2996). Thanks to Joseph Burling for reporting. - - ``` - This data.table has either been loaded from disk (e.g. using readRDS()/load()) or constructed - manually (e.g. using structure()). Please run setDT() or alloc.col() on it first (to pre-allocate - space for new columns) before adding new columns by reference to it. - ``` - -3. `setorder` on a superset of a keyed `data.table`'s key now retains its key, [#3456](https://github.com/Rdatatable/data.table/issues/3456). For example, if `a` is the key of `DT`, `setorder(DT, a, -v)` will leave `DT` keyed by `a`. - -4. New option `options(datatable.quiet = TRUE)` turns off the package startup message, [#3489](https://github.com/Rdatatable/data.table/issues/3489). `suppressPackageStartupMessages()` continues to work too. Thanks to @leobarlach for the suggestion inspired by `options(tidyverse.quiet = TRUE)`. We don't know of a way to make a package respect the `quietly=` option of `library()` and `require()` because the `quietly=` isn't passed through for use by the package's own `.onAttach`. If you can see how to do that, please submit a patch to R. - -5. When loading a `data.table` from disk (e.g. with `readRDS`), best practice is to run `setDT()` on the new object to assure it is correctly allocated memory for new column pointers. Barring this, unexpected behavior can follow; for example, if you assign a new column to `DT` from a function `f`, the new columns will only be assigned within `f` and `DT` will be unchanged. The `verbose` messaging in this situation is now more helpful, [#1729](https://github.com/Rdatatable/data.table/issues/1729). Thanks @vspinu for sharing his experience to spur this. - -6. New vignette _Using `.SD` for Data Analysis_, a deep dive into use cases for the `.SD` variable to help illuminate this topic which we've found to be a sticking point for beginning and intermediate `data.table` users, [#3412](https://github.com/Rdatatable/data.table/issues/3412). - -7. Added a note to `?frank` clarifying that ranking is being done according to C sorting (i.e., like `forder`), [#2328](https://github.com/Rdatatable/data.table/issues/2328). Thanks to @cguill95 for the request. - -8. Historically, `dcast` and `melt` were built as enhancements to `reshape2`'s own `dcast`/`melt`. We removed dependency on `reshape2` in v1.9.6 but maintained some backward compatibility. As that package has been superseded since December 2017, we will begin to formally complete the split from `reshape2` by removing some last vestiges. In particular we now warn when redirecting to `reshape2` methods and will later error before ultimately completing the split; see [#3549](https://github.com/Rdatatable/data.table/issues/3549) and [#3633](https://github.com/Rdatatable/data.table/issues/3633). We thank the `reshape2` authors for their original inspiration for these functions, and @ProfFancyPants for testing and reporting regressions in dev which have been fixed before release. - -9. `DT[col]` where `col` is a column containing row numbers of itself to select, now suggests the correct syntax (`DT[(col)]` or `DT[DT$col]`), [#697](https://github.com/Rdatatable/data.table/issues/697). This expands the message introduced in [#1884](https://github.com/Rdatatable/data.table/issues/1884) for the case where `col` is type `logical` and `DT[col==TRUE]` is suggested. - ---- - -Role Definition - -There are two roles which are related to translations: - -Translation Manager: responsible for reviewing translation-related PRs, including creating CI for checking, as in PR#6358. should be familiar with data.table internals, and will need to understand the basics of gettext() and its interface through R, including possibly through the potools package. - -Translator: a project member involved with translating vignettes, messages, etc., from English to another language. Translators are encouraged to offer feedback on the quality and user-friendliness of English-language messages. They don't necessarily have to understand any data.table internals, though of course familiarity with the package will help lead to higher-quality translations. - -Communication between devs and translation teams - -Best way to communicate with data.table devs is by creating an issue, https://github.com/Rdatatable/data.table/issues/new - -There are several teams that can be mentioned in issues: - -Collective: https://github.com/orgs/Rdatatable/teams/translators (all translators; mention with @Rdatatable/translators) - -Language-specific: https://github.com/orgs/Rdatatable/teams/translators/teams (mention with @Rdatatable/, for e.g. @Rdatatable/French) - -Software Tools - -Translating the data.table messages from zero can be easier if data.table.pot and R-data.table.pot are split in multiple, smaller files. For that, place split.R and combine.R in an empty directory created ""besides"" the data.table source code (so that, setting the working directory as that new one, ../data.table points to the source code), set MY_LOCALE to something like ""zh_CN"" or ""es"", and make sure you have installed the {potools} package and the gettext utilities. Run split.R to create the split PO files, and then translate all of them. After that, and making sure the POT files in ../data.table/po/ are current, run combine.R to create the two combined PO files, which you can then move to ../data.table/po/. Check the beginning of the PO files (the part before the first translated message) with a text editor and make any necessary adjustments. Disclaimer: the scripts were tested on Linux only, and depend on a hardcoded list of source files with no messages. They were created for the Brazilian Portuguese translation and later made more general, but were attached to the wiki before being tested by other translation teams. - -The {potools} website lists applications for translating PO files, among other software packaged created for otherwise manipulating them. - -TODO add details about what software tools were used by the various translation teams, to make it easier to generate the translated files. - -TODO is it possible to join forces with base R's weblate? See discussions in https://github.com/Rdatatable/data.table/issues/6370 and (older) https://contributor.r-project.org/translations/ https://github.com/Rdatatable/data.table/pull/6199#issuecomment-2259220924 - -Please check https://contributor.r-project.org/translations/Conventions_for_Languages/#languages-and-contributions to see if your language already has translation guidelines in base R. - -Addend - -The wiki doesn't permit attaching R files, so the scripts are here for now. - -split.R: - -#!/usr/bin/env Rscript - -# MY_LOCALE <- NULL # in example, ""pt_BR"", ""fr"" etc. - -if (!exists(""MY_LOCALE"") | is.null(MY_LOCALE) | !is.character(MY_LOCALE) | length(MY_LOCALE) != 1) { - stop(""Please set MY_LOCALE in the script to something like \""pt_BR\"" or \""es\"""") -} - -DT_SRC <- ""../data.table"" -if (!dir.exists(DT_SRC)) { - stop(sprintf(""Could not find %s. Is %s the intended working directory?"", DT_SRC, getwd)) -} - -library(potools) - ---- - -\code{fread} is for \emph{regular} delimited files; i.e., where every row has the same number of columns. In future, secondary separator (\code{sep2}) may be specified \emph{within} each column. Such columns will be read as type \code{list} where each cell is itself a vector. -} -\usage{ -fread(input, file, text, cmd, sep=""auto"", sep2=""auto"", dec=""auto"", quote=""\"""", -nrows=Inf, header=""auto"", -na.strings=getOption(""datatable.na.strings"",""NA""), # due to change to """"; see NEWS -stringsAsFactors=FALSE, verbose=getOption(""datatable.verbose"", FALSE), -skip=""__auto__"", select=NULL, drop=NULL, colClasses=NULL, -integer64=getOption(""datatable.integer64"", ""integer64""), -col.names, -check.names=FALSE, encoding=""unknown"", -strip.white=TRUE, fill=FALSE, blank.lines.skip=FALSE, comment.char="""", -key=NULL, index=NULL, -showProgress=getOption(""datatable.showProgress"", interactive()), -data.table=getOption(""datatable.fread.datatable"", TRUE), -nThread=getDTthreads(verbose), -logical01=getOption(""datatable.logical01"", FALSE), -logicalYN=getOption(""datatable.logicalYN"", FALSE), -keepLeadingZeros = getOption(""datatable.keepLeadingZeros"", FALSE), -yaml=FALSE, tmpdir=tempdir(), tz=""UTC"" -) -} -\arguments{ - \item{input}{ A single character string. The value is inspected and deferred to either \code{file=} (if no \\n present), \code{text=} (if at least one \\n is present) or \code{cmd=} (if no \\n is present, at least one space is present, and it isn't a file name). Exactly one of \code{input=}, \code{file=}, \code{text=}, or \code{cmd=} should be used in the same call. } - \item{file}{ File name in working directory, path to file (passed through \code{\link[base]{path.expand}} for convenience), or a URL starting http://, file://, etc. Compressed files with extension \file{.gz} and \file{.bz2} are supported if the \code{R.utils} package is installed. } - \item{text}{ The input data itself as a character vector of one or more lines, for example as returned by \code{readLines()}. } - \item{cmd}{ A shell command that pre-processes the file; e.g. \code{fread(cmd=paste(""grep"",word,""filename""))}. See Details. } - \item{sep}{ The separator between columns. Defaults to the character in the set \code{[,\\t |;:]} that separates the sample of rows into the most number of lines with the same number of fields. Use \code{NULL} or \code{""""} to specify no separator; i.e. each line a single character column like \code{base::readLines} does.} - \item{sep2}{ The separator \emph{within} columns. A \code{list} column will be returned where each cell is a vector of values. This is much faster using less working memory than \code{strsplit} afterwards or similar techniques. For each column \code{sep2} can be different and is the first character in the same set above [\code{,\\t |;}], other than \code{sep}, that exists inside each field outside quoted regions in the sample. NB: \code{sep2} is not yet implemented. } - \item{nrows}{ The maximum number of rows to read. Unlike \code{read.table}, you do not need to set this to an estimate of the number of rows in the file for better speed because that is already automatically determined by \code{fread} almost instantly using the large sample of lines. \code{nrows=0} returns the column names and typed empty columns determined by the large sample; useful for a dry run of a large file or to quickly check format consistency of a set of files before starting to read any of them. } - \item{header}{ Does the first data line contain column names? Defaults according to whether every non-empty field on the first data line is type character. If so, or TRUE is supplied, any empty column names are given a default name. }","`data.table` is an R package that provides an enhanced version of the standard `data.frame`. It is designed for high-performance data manipulation, focusing on speed and memory efficiency, particularly for large datasets (e.g., 100GB in RAM or up to two billion rows). - -### Core Principles -The project is guided by several key design decisions: -* **Efficiency:** It uses low-level parallelism (OpenMP) to speed up common operations and employs reference semantics to modify data without making unnecessary copies. -* **Concise Syntax:** The syntax is designed to minimize redundancy, making code faster to type and easier to read. -* **Minimal Dependencies:** It has no external dependencies other than base R, simplifying production maintenance. -* **Stability:** There is a strong preference for user-friendly back-compatibility and support for older versions of R (currently back to R 3.5.0). - -### General Syntax: `DT[i, j, by]` -The syntax is structured like a query, analogous to SQL: -* **`i`:** Where or Order By (filtering or reordering rows). -* **`j`:** Select or Update (computing on columns). -* **`by`:** Group By (aggregating data). - -**How to read it:** ""Take `DT`, subset/reorder rows using `i`, then calculate `j`, grouped by `by`."" - -### Key Features -* **Fast I/O:** Includes `fread` for rapid file reading and `fwrite` for parallelized file writing. -* **Reference Semantics:** The `:=` operator and `set*` functions (like `setkey`, `setorder`, `setnames`) modify data ""by reference,"" meaning they update the object in place without copying it in memory. -* **Advanced Joins:** Supports ordered joins (rolling forwards, backwards, or nearest), non-equi joins (using operators like `>`, `<`), and overlapping range joins. -* **GForce Optimization:** Internally optimizes common grouped operations (like `sum`, `mean`, `min`, `max`) to run much faster than standard R equivalents. -* **Reshaping:** High-performance versions of `melt` (wide-to-long) and `dcast` (long-to-wide). - -### Community and Ecosystem -`data.table` is one of the most-starred R packages on GitHub and is used as a dependency by hundreds of CRAN and Bioconductor packages. It is maintained by a core team and a community of contributors, with governance focused on maintaining a self-sustaining ecosystem for efficient big data analysis. - -For more details, you can view the package vignettes by typing `vignette(package=""data.table"")` in your R console or use `?data.table` to see the primary documentation and arguments.",100 diff --git a/systems/docgpt/logs/interactions_2026-02-11_120634.jsonl b/systems/docgpt/logs/interactions_2026-02-11_120634.jsonl deleted file mode 100644 index 18957c1..0000000 --- a/systems/docgpt/logs/interactions_2026-02-11_120634.jsonl +++ /dev/null @@ -1,3 +0,0 @@ -{"timestamp": "2026-02-11T12:07:22", "session_id": "1471220254439899209", "question": "no", "retrieved_context": "20090925 AYE 26.8 26.98 26.64 26.71 22841 20090928 AYE 26.8 27.14 26.71 27.01 11299 20090929 AYE 26.97 27.18 26.72 26.94 21074 20090930 AYE 26.91 27.04 26.32 26.52 21318 20091001 AYE 26.41 26.48 25.61 25.63 22455 20091002 AYE 25.36 25.6 25.07 25.4 17742 20091005 AYE 25.41 25.99 25.18 25.88 26956 20091006 AYE 25.9 26.25 25.74 26.12 20282 20091007 AYE 26.02 26.13 25.74 25.97 12686 20091008 AYE 26.11 26.13 25.81 25.86 16599 20091009 AYE 25.89 26.05 25.72 25.84 23147 20091012 AYE 26.03 26.24 25.82 26.02 11314 20091013 AYE 25.95 26.04 25.55 25.58 17254 20091014 AYE 25.79 26 25.4 25.66 19319 20091015 AYE 25.65 26.11 25.65 26.01 26979 20091016 AYE 25.85 26.6 25.72 26.43 27533 20091019 AYE 26.46 26.91 26.21 26.75 17019 20091020 AYE 26.81 26.83 26.44 26.78 17225 20091021 AYE 26.78 27.15 26.67 26.67 18620 20091022 AYE 26.59 26.65 26.3 26.52 22360 20091023 AYE 26.73 27.03 26.11 26.3 19962 20091026 AYE 26.31 26.79 25.71 25.82 16248 20091027 AYE 25.8 25.98 25.32 25.35 18698 20091028 AYE 25.28 25.49 24.95 25.02 29643 20091105 AYE 22.54 22.99 22.54 22.99 24919 20091106 AYE 22.9 23.03 22.55 22.68 22038 20091109 AYE 22.88 23.22 22.71 23.22 15980 20091110 AYE 23.11 23.31 22.96 23.06 18702 20091111 AYE 22.52 23.06 22.48 22.76 41960 20091112 AYE 22.78 22.86 22.36 22.43 17049 20091113 AYE 22.44 22.57 22.16 22.4 26759 20091116 AYE 22.43 22.73 22.42 22.68 17993 20091117 AYE 22.67 22.76 22.47 22.6 15328 20091118 AYE 22.56 22.78 22.499 22.6 19040 20091119 AYE 22.46 22.55 22.01 22.1 29953 20091120 AYE 22.05 22.2 21.94 22.09 26083 20091123 AYE 22.44 22.58 22.13 22.25 15668 20091124 AYE 22.3 22.33 21.99 22.26 19701 20091125 AYE 22.24 22.45 22.21 22.34 13752 20091127 AYE 21.96 22.255 21.85 21.95 6768 20091130 AYE 21.86 22.1 21.84 21.98 24152 20091201 AYE 22.14 22.52 22.11 22.3 17228 20091202 AYE 22.31 22.7 22.3 22.65 17861 20091203 AYE 22.68 22.92 22.43 22.69 17993 20091204 AYE 22.84 23.0497 22.28 22.65 20840 20091207 AYE 22.55 23.01 22.52 22.7 15095 20091208 AYE 22.65 22.71 22.33 22.54 14779 20091209 AYE 22.57 22.62 22.125 22.31 15036 20091210 AYE 22.26 22.71 22.26 22.62 17616 20091211 AYE 22.75 23.01 22.55 22.97 24376 20091214 AYE 23.04 23.36 23 23.29 19258 20091215 AYE 23.25 23.41 23.13 23.38 16977 20091216 AYE 23 23.38 22.94 23.15 33733 20091217 AYE 23.12 23.65 22.9 23.62 36202 20091218 AYE 23.71 23.91 23.46 23.55 20561 20091221 AYE 23.58 24.3 23.55 24.19 24204 20091222 AYE 24.21 24.33 23.86 24.04 12611 20091223 AYE 24.15 24.25 23.88 24.07 8722 20091224 AYE 24.04 24.29 24.03 24.11 4207 20091228 AYE 24.22 24.34 24.05 24.22 11425 20091229 AYE 24.22 24.5 24.13 24.36 18247 20091230 AYE 24.2 24.32 23.79 23.83 20648 20091231 AYE 23.86 23.9 23.45 23.48 10208 20100104 AYE 23.58 23.66 23.34 23.52 27198 20100105 AYE 23.51 23.5499 23.07 23.13 24302 20100106 AYE 23.17 23.71 23 23.66 31455 20100107 AYE 23.58 23.58 23.2 23.21 21737 20100108 AYE 23.12 23.18 22.95 22.99 15612 20100111 AYE 23.04 23.1 22.78 23.04 25592 20100112 AYE 22.97 23.12 22.7 22.95 19785 20100113 AYE 23.05 23.08 22.75 22.95 14783 20100114 AYE 22.95 22.97 22.71 22.72 12353 20100115 AYE 22.62 22.7 22.35 22.57 22606 20100119 AYE 22.4 22.72 22.3 22.72 24003 20100120 AYE 22.64 22.75 22.46 22.75 22720 20100121 AYE 22.74 23 22.28 22.34 36671 20100122 AYE 22.31 22.36 21.74 21.77 42210 20100125 AYE 21.95 22.07 21.76 21.92 14996 20100126 AYE 21.91 21.94 21.53 21.65 17558 20100127 AYE 21.65 21.65 21.08 21.26 26624 20100128 AYE 21.26 21.36 20.86 21.09 24743 20100129 AYE 21.26 21.31 20.91 20.95 20751 20100201 AYE 21.13 21.13 20.8 20.95 18613 20100202 AYE 20.94 21.0501 20.75 20.9 31327 20100203 AYE 20.89 21.1 20.71 21.01 26580 20100204 AYE 20.91 21.03 20.43 20.49 50574 20100205 AYE 20.53 21.195 20.4 20.99 61650 20100208 AYE 21.11 21.2 20.82 20.89 32660 20100209 AYE 21.07 21.61 21.02 21.18 32168 20100210 AYE 21.18 21.19 20.82 21.02 23162 20100211 AYE 22.78 23.77 22.78 23.55 281235 20100212 AYE 23.49 23.56 22.54 22.72 135049 20100216 AYE 23.05 23.22 22.6 22.84 54802 20100217 AYE 22.87 22.9965 22.49 22.59 36250\n\n---\n\n9.27 9.31 186575 20091217 JAVA 9.3 9.33 9.21 9.29 334541 20091218 JAVA 9.32 9.35 9.32 9.33 116914 20091221 JAVA 9.33 9.36 9.33 9.35 137242 20091222 JAVA 9.35 9.36 9.32 9.33 91109 20091223 JAVA 9.33 9.36 9.33 9.36 110515 20091224 JAVA 9.36 9.3605 9.34 9.35 23676 20091228 JAVA 9.36 9.38 9.35 9.38 53897 20091229 JAVA 9.38 9.38 9.36 9.37 34344 20091230 JAVA 9.37 9.38 9.36 9.38 43685 20091231 JAVA 9.37 9.37 9.33 9.37 62886 20100104 JAVA 9.37 9.4 9.36 9.38 70839 20100105 JAVA 9.38 9.4 9.38 9.39 41146 20100106 JAVA 9.39 9.39 9.36 9.36 33112 20100107 JAVA 9.37 9.4 9.36 9.4 49974 20100108 JAVA 9.37 9.39 9.37 9.38 29907 20100111 JAVA 9.39 9.41 9.38 9.41 51734 20100112 JAVA 9.41 9.43 9.39 9.42 89459 20100113 JAVA 9.4 9.42 9.4 9.42 54463 20100114 JAVA 9.41 9.43 9.4 9.42 51620 20100115 JAVA 9.43 9.43 9.37 9.42 250474 20100119 JAVA 9.39 9.42 9.39 9.41 70431 20100120 JAVA 9.41 9.45 9.41 9.43 54027 20100121 JAVA 9.47 9.48 9.47 9.47 126642 20100122 JAVA 9.47 9.48 9.46 9.46 90326 20100125 JAVA 9.475 9.48 9.47 9.48 36967 20100126 JAVA 9.47 9.49 9.46 9.49 118044 20090821 JBL 10.23 10.78 9.99 10.71 48010 20090824 JBL 10.77 10.97 10.51 10.56 35844 20090825 JBL 10.72 11.09 10.6 10.8 26991 20090826 JBL 10.62 10.89 10.52 10.63 17269 20090827 JBL 10.7 10.81 10.49 10.81 19949 20090828 JBL 10.99 11.24 10.96 11.16 28957 20090831 JBL 11.14 11.14 10.81 10.95 30076 20090901 JBL 10.77 11.28 10.62 10.95 56248 20090902 JBL 10.92 10.93 10.41 10.56 48428 20090903 JBL 10.57 10.73 10.505 10.72 26144 20090904 JBL 10.74 11.09 10.58 11.08 27434 20090909 JBL 11.11 12 11.03 11.83 44339 20090910 JBL 11.83 11.96 11.7 11.78 28381 20090911 JBL 11.8 11.88 11.55 11.77 17501 20090914 JBL 11.67 11.91 11.45 11.91 26301 20090915 JBL 11.89 12.24 11.84 11.89 37650 20090916 JBL 12 12.48 12 12.2 51955 20090917 JBL 12.16 12.56 11.91 11.91 39134 20090918 JBL 12.05 12.41 11.9 12.41 92549 20090921 JBL 12.3 12.46 12.17 12.4 35190 20090922 JBL 12.47 12.4901 12.33 12.34 27170 20090923 JBL 12.35 13.18 12.35 12.69 55449 20090924 JBL 12.92 12.92 12.51 12.53 53959 20090925 JBL 12.39 12.41 11.54 11.87 66130 20090928 JBL 11.97 12.52 11.93 12.38 33261 20090929 JBL 12.47 12.53 12.07 12.28 70816 20090930 JBL 13.04 13.55 12.93 13.41 145041 20091001 JBL 13.41 13.46 12.89 12.89 81367 20091002 JBL 12.51 13.03 12.51 12.94 61661 20091005 JBL 13.06 13.68 12.98 13.6 66526 20091006 JBL 13.7 14.06 13.64 13.88 71935 20091007 JBL 13.82 13.97 13.64 13.92 43895 20091008 JBL 14.02 14.3 13.82 13.95 53530 20091009 JBL 14.03 14.38 13.9 14.35 23601 20091012 JBL 14.5 14.69 14.41 14.56 32170 20091013 JBL 14.57 14.73 14.36 14.64 47996 20091014 JBL 14.9 15.42 14.77 15.38 59031 20091015 JBL 15.26 15.28 15 15.2 28201 20091016 JBL 15.07 15.17 14.58 14.78 40785 20091019 JBL 14.81 15.34 14.81 15.18 36457 20091020 JBL 15.33 15.33 14.87 15.12 29727 20091021 JBL 14.97 15.45 14.9 14.96 33329 20091022 JBL 14.86 15.0076 14.57 14.88 29194 20091023 JBL 15.05 15.21 14.81 14.96 37697 20091026 JBL 15.02 15.4 14.94 15 76063 20091027 JBL 15.01 15.29 14.6 14.65 53327 20091028 JBL 14.52 14.65 13.66 13.69 56446 20091105 JBL 13.85 14.36 13.77 14.24 45503 20091106 JBL 14.05 14.58 14 14.29 29990 20091109 JBL 14.55 14.91 14.47 14.83 27931 20091110 JBL 14.74 14.99 14.5 14.77 26049 20091111 JBL 14.87 15 14.65 14.7 34739 20091112 JBL 14.69 14.71 14.365 14.45 26433 20091113 JBL 14.48 14.585 14.32 14.48 20148 20091116 JBL 14.58 14.58 14.33 14.52 40342 20091117 JBL 14.41 14.51 14.2817 14.42 23841 20091118 JBL 14.4 14.5 14.18 14.23 20795 20091119 JBL 14.11 14.11 13.43 13.75 30151 20091120 JBL 13.6 13.77 13.5 13.63 22447 20091123 JBL 13.92 14.1 13.79 13.93 21814 20091124 JBL 13.87 13.93 13.33 13.37 30353 20091125 JBL 13.39 13.67 13.34 13.53 16662 20091127 JBL 13.07 13.51 12.77 13.34 12380 20091130 JBL 13.3 13.36 13.01 13.31 26205 20091201 JBL 13.4 13.64 13.24 13.27 29217 20091202 JBL 13.09 13.23 13 13.1 35237 20091203 JBL 13.11 13.34 12.81 12.86 42815 20091204 JBL 13.12 13.35 12.81 12.94 48359 20091207 JBL 12.95 13.39 12.93 13.25 30656 20091208 JBL 13.16\n\n---\n\n41.35 41.555 41.26 41.5 17212 20100405 STJ 41.56 41.83 41.29 41.51 18442 20100406 STJ 41.35 41.59 41.1 41.22 17358 20100407 STJ 41 41.06 40.61 40.81 30351 20100408 STJ 40.84 40.94 40.51 40.79 21837 20100409 STJ 40.76 41.37 40.59 41.24 17293 20100412 STJ 41.96 42.87 41.96 42.46 50159 20100413 STJ 42.32 42.4 41.9 42.31 28456 20100414 STJ 42.23 42.4 42.05 42.24 21834 20100415 STJ 42.14 42.29 41.78 41.94 26087 20100416 STJ 41 41.85 40.75 40.88 67446 20100419 STJ 40.87 41.15 40.79 40.9 34594 20100420 STJ 41.05 41.23 40.88 41 43689 20100421 STJ 42 42.18 41.33 41.75 66452 20100422 STJ 41.84 42.5 41.26 41.67 46986 20100423 STJ 41.59 41.75 40.56 40.9 51666 20100426 STJ 40.96 41.04 40.17 40.19 23978 20100427 STJ 40 40.74 39.97 40.42 43844 20100428 STJ 40.43 40.8 40.08 40.59 26981 20100429 STJ 40.67 41.14 40.57 40.63 23693 20100430 STJ 40.71 41 40.38 40.82 24568 20100503 STJ 40.74 40.83 40.17 40.74 19327 20100504 STJ 40.33 40.42 39.7 39.94 17440 20100505 STJ 39.81 39.81 38.46 38.64 65739 20100506 STJ 38.64 39 34 37.75 66586 20100507 STJ 37.87 37.87 36.4 37.15 70804 20100510 STJ 38.07 38.67 37.97 38.24 29237 20100511 STJ 38.87 39 38.3 38.4 30422 20100512 STJ 38.36 39.23 38.21 39.19 30935 20100513 STJ 40.7 40.7 39.2 39.31 27265 20100514 STJ 39.24 39.31 38.43 38.59 25705 20100517 STJ 38.75 39.04 38.14 38.68 23317 20100518 STJ 38.88 39.14 38.36 38.46 20672 20100519 STJ 38.29 38.57 38.03 38.4 23947 20100520 STJ 37.61 37.97 37.31 37.4 31896 20100521 STJ 36.98 37.75 36.68 37.18 51571 20100524 STJ 36.94 37.695 36.94 37.14 26080 20100525 STJ 36.52 37.06 36.32 37.05 33854 20100526 STJ 37.11 37.45 36.74 36.84 25998 20100527 STJ 37.27 37.77 37.15 37.74 22422 20100528 STJ 37.65 37.7 37.21 37.34 17190 20100601 STJ 37.12 37.39 36.4 36.45 27639 20100602 STJ 36.57 37.44 36.35 37.44 24321 20100603 STJ 37.45 38.15 37.38 37.99 23475 20100604 STJ 37.4 37.53 36.4 36.55 35699 20100607 STJ 36.63 36.63 36.24 36.24 29664 20100608 STJ 36.09 36.53 36.07 36.49 29462 20100609 STJ 36.98 36.98 35.99 36.07 32781 20100610 STJ 36.46 36.77 36.23 36.56 43307 20100611 STJ 36.25 36.88 35.66 36.88 19527 20100614 STJ 37 37.42 36.91 36.91 15209 20100615 STJ 37.25 37.66 37.03 37.66 13934 20100616 STJ 37.22 37.79 37.22 37.77 12097 20100617 STJ 37.98 37.98 37.58 37.79 15270 20100618 STJ 37.84 37.98 37.39 37.39 30448 20100621 STJ 37.94 38.11 37.4 37.48 19064 20100622 STJ 37.56 37.62 36.74 36.78 26234 20100623 STJ 36.76 36.76 36.14 36.39 26457 20100624 STJ 36.15 37 35.99 36.66 35199 20100625 STJ 36.78 37.155 36.68 37.06 30454 20100628 STJ 37.1 37.76 37.06 37.5 29547 20100629 STJ 37.16 37.16 36.39 36.55 29989 20100630 STJ 36.42 36.62 36.0519 36.09 27988 20100701 STJ 36.02 36.02 34.51 35.28 55207 20100702 STJ 35.37 35.77 35.29 35.48 17310 20100706 STJ 35.65 35.94 35.24 35.59 18798 20100707 STJ 35.53 36.45 35.45 36.4 43021 20100708 STJ 36.58 36.82 36.23 36.45 27655 20100709 STJ 36.58 36.86 36.5 36.7 20206 20100712 STJ 36.62 36.76 36.44 36.65 15205 20100713 STJ 36.79 37.25 36.74 37.17 29449 20100714 STJ 37 37.24 36.81 36.99 24287 20100715 STJ 36.85 37.15 36.37 36.76 28677 20100716 STJ 36.54 36.79 35.61 35.68 32226 20100719 STJ 35.74 35.96 35.52 35.76 21183 20100720 STJ 35.47 35.675 34.98 35.64 29579 20100721 STJ 35.73 35.73 34.25 34.62 54957 20100722 STJ 36.53 37.49 35.3 35.39 65515 20100723 STJ 35.43 36.97 35.43 36.81 57473 20100726 STJ 36.78 37.44 36.71 37.21 32998 20100727 STJ 37.35 37.51 36.87 37.5 33437 20100728 STJ 37.42 37.46 36.53 36.54 25251 20100729 STJ 36.76 36.97 35.99 36.35 34330 20100730 STJ 35.95 36.98 35.6 36.77 22168 20100802 STJ 37.2 37.52 37.13 37.22 23055 20100803 STJ 37.13 37.88 37.12 37.69 32904 20100804 STJ 37.67 38.26 37.64 38.2 18076 20100805 STJ 38.17 38.32 37.76 38.31 19988 20100806 STJ 38.03 38.54 37.8 38.51 19684 20100809 STJ 38.49 38.56 37.86 38.53 20717 20100810 STJ 38.22 38.69 37.88 38.46 18865 20100811 STJ 38.03 38.05 37.18 37.28 17932 20100812 STJ 37.05 37.52 36.8 37.44 14716 20100813 STJ 37.3 37.52 37.21 37.23 11866 20100816 STJ 37.06 37.15 36.8 36.9\n\n---\n\nsee .ci/README.md\n\n---\n\n14.03 13.75 14 24969 20100316 JNS 14.05 14.1 13.87 14 14858 20100317 JNS 14.07 14.4 14.07 14.35 26312 20100318 JNS 14.26 14.4 14.23 14.37 16775 20100319 JNS 14.31 14.41 14.01 14.02 24438 20100322 JNS 13.92 14.15 13.79 14.15 15669 20100323 JNS 14.21 14.37 13.99 14.33 14384 20100324 JNS 14.22 14.36 13.95 14.13 16722 20100325 JNS 14.25 14.83 14.21 14.43 39371 20100326 JNS 14.44 14.63 14.12 14.27 15340 20100329 JNS 14.38 14.64 14.35 14.54 21047 20100330 JNS 14.52 14.6 14.26 14.45 12239 20100331 JNS 14.31 14.51 14.21 14.29 17425 20100401 JNS 14.77 15.07 14.63 14.7 33950 20100405 JNS 14.78 15.03 14.74 14.98 18832 20100406 JNS 14.97 15.33 14.92 15.3 23833 20100407 JNS 15.23 15.35 14.82 14.9 33265 20100408 JNS 14.88 14.91 14.61 14.68 32790 20100409 JNS 14.7 14.8 14.52 14.59 37829 20100412 JNS 14.65 14.77 14.59 14.67 13976 20100413 JNS 14.645 14.9 14.57 14.86 13512 20100414 JNS 14.91 15.46 14.91 15.45 25093 20100415 JNS 15.43 15.72 15.25 15.72 27257 20100416 JNS 15.61 15.67 14.84 15.09 52990 20100419 JNS 14.5 15.22 14.5 14.83 55265 20100420 JNS 14.98 15.505 14.83 15.38 36271 20100421 JNS 15.41 15.49 14.935 15.17 34089 20100422 JNS 14.4 14.5 13.95 14.14 106707 20100423 JNS 14 14.45 14 14.44 59267 20100426 JNS 14.36 14.47 14.22 14.27 53392 20100427 JNS 14.11 14.21 13.66 13.66 64682 20100428 JNS 13.86 14.04 13.52 13.74 43924 20100429 JNS 13.92 14.6 13.92 14.56 38645 20100430 JNS 14.54 14.65 14.08 14.08 34042 20100503 JNS 14.23 14.4 14.07 14.32 25927 20100504 JNS 14.11 14.12 13.38 13.49 51938 20100505 JNS 13.27 13.68 13.03 13.2 24317 20100506 JNS 13.11 13.42 11.6 12.5 65648 20100507 JNS 12.48 12.6 11.82 12.11 70227 20100510 JNS 12.92 13.13 12.33 12.98 34186 20100511 JNS 12.68 13.02 12.56 12.83 32801 20100512 JNS 12.83 13.21 12.7 13.18 32567 20100513 JNS 13.11 13.26 12.79 12.8 28155 20100514 JNS 12.64 12.64 12.1 12.31 40907 20100517 JNS 12.32 12.55 11.66 12.34 63630 20100518 JNS 12.51 12.72 11.75 11.87 47004 20100519 JNS 11.78 11.99 11.43 11.78 51617 20100520 JNS 11.46 11.57 11.02 11.02 57647 20100521 JNS 10.78 11.37 10.51 11.36 66159 20100524 JNS 10.98 11.12 10.51 10.51 69680 20100525 JNS 10.22 10.81 10 10.79 68711 20100526 JNS 10.84 11.02 10.23 10.28 65956 20100527 JNS 10.58 10.81 10.36 10.8 52828 20100528 JNS 10.8 10.82 10.52 10.66 37594 20100601 JNS 10.48 10.57 10.07 10.08 32684 20100602 JNS 10.21 10.45 9.93 10.45 32522 20100603 JNS 10.59 10.59 10.27 10.45 37667 20100604 JNS 10.15 10.34 9.87 9.95 59422 20100607 JNS 9.99 10.12 9.62 9.68 41755 20100608 JNS 9.73 9.85 9.37 9.76 39952 20100609 JNS 9.86 9.94 9.55 9.61 48196 20100610 JNS 9.78 10.45 9.72 10.44 70352 20100611 JNS 10.23 10.65 10.2 10.6 38109 20100614 JNS 10.73 10.745 10.39 10.39 31324 20100615 JNS 10.54 10.56 10.39 10.43 40405 20100616 JNS 10.34 10.42 10.19 10.3 34636 20100617 JNS 10.31 10.39 10.08 10.2 26475 20100618 JNS 10.21 10.3 10.17 10.22 18769 20100621 JNS 10.38 10.46 10.11 10.15 18436 20100622 JNS 10.21 10.3 9.99 10.03 29151 20100623 JNS 10 10.1 9.77 9.87 25919 20100624 JNS 9.81 9.84 9.42 9.48 32325 20100625 JNS 9.62 9.8 9.44 9.72 52328 20100628 JNS 9.72 9.91 9.62 9.73 20703 20100629 JNS 9.32 9.57 8.92 9 55669 20100630 JNS 9.04 9.25 8.84 8.88 41806 20100701 JNS 9.08 9.2 8.63 9 49174 20100702 JNS 9.07 9.18 8.76 8.87 34495 20100706 JNS 9.08 9.35 8.73 8.81 34455 20100707 JNS 8.83 9.54 8.82 9.49 48113 20100708 JNS 9.615 9.78 9.52 9.76 33039 20100709 JNS 10.13 10.15 9.86 10.09 31576 20100712 JNS 10.04 10.05 9.83 9.87 29948 20100713 JNS 10.01 10.28 10 10.24 50987 20100714 JNS 10.12 10.22 9.87 9.96 36132 20100715 JNS 10.03 10.05 9.72 9.96 46441 20100716 JNS 9.79 9.84 9.39 9.45 47192 20100719 JNS 9.46 9.54 9.23 9.46 31766 20100720 JNS 9.23 9.59 9.18 9.57 35214 20100721 JNS 9.75 9.78 9.45 9.47 40028 20100722 JNS 9.99 11.04 9.75 10.59 141643 20100723 JNS 10.61 10.7508 10.39 10.71 62987 20100726 JNS 10.74 11.01 10.6 10.9 40445 20100727 JNS 10.94 11.08 10.66 10.7 35694 20100728 JNS 10.62 10.79 10.5 10.58 25690 20100729 JNS 10.68 10.95 10.38 10.55 36579 20100730 JNS 10.38 10.65 10.35\n\n---\n\nFII 22.81 23.04 22.4 22.4 17874 20100525 FII 21.91 22.55 21.8 22.51 20575 20100526 FII 22.68 22.83 22.27 22.38 16335 20100527 FII 22.72 22.77 22.27 22.73 19763 20100528 FII 22.61 22.69 22.1 22.21 15112 20100601 FII 21.99 22.18 21.6 21.6 11698 20100602 FII 21.74 21.76 21.38 21.58 30593 20100603 FII 21.7 22.29 21.57 22.26 22183 20100604 FII 21.7 22.2826 21.7 21.8 23094 20100607 FII 21.99 21.99 21.17 21.17 17787 20100608 FII 21.15 21.29 20.86 21.26 14701 20100609 FII 21.41 21.41 20.82 20.9 21190 20100610 FII 21.18 21.81 21.06 21.81 16537 20100611 FII 21.66 22.3003 21.55 22.25 16034 20100614 FII 22.68 22.95 22.23 22.26 25142 20100615 FII 22.36 22.75 22.22 22.72 17777 20100616 FII 22.7 22.78 22.47 22.69 9105 20100617 FII 22.64 22.72 22.19 22.45 8317 20100618 FII 22.44 22.52 22.06 22.15 19236 20100621 FII 22.36 22.39 21.93 22.01 14594 20100622 FII 22.01 22.13 21.68 21.69 11654 20100623 FII 21.75 21.96 21.66 21.8 10700 20100624 FII 21.68 21.68 21.08 21.13 8821 20100625 FII 21.21 21.44 21.06 21.32 15394 20100628 FII 21.39 21.87 21.32 21.61 12457 20100629 FII 21.39 21.49 20.82 21.05 20192 20100630 FII 20.96 21.16 20.67 20.71 15193 20100701 FII 20.67 20.93 20.28 20.59 12676 20100702 FII 20.83 20.83 20.34 20.49 5784 20100706 FII 20.65 20.88 20.26 20.39 8066 20100707 FII 20.45 21.07 20.45 21.04 10087 20100708 FII 21.25 21.37 20.89 21.1 12988 20100709 FII 21.18 21.33 21.07 21.24 12800 20100712 FII 21.17 21.28 21.01 21.12 8105 20100713 FII 21.28 21.42 21.12 21.23 21004 20100714 FII 21.24 21.41 21.08 21.38 18182 20100715 FII 21.34 21.38 20.79 21.04 14446 20100716 FII 20.88 21.32 20.76 20.84 20999 20100719 FII 20.93 21.08 20.74 20.96 9614 20100720 FII 20.65 21.35 20.62 21.33 8605 20100721 FII 21.55 21.86 21.36 21.38 20446 20100722 FII 21.54 22.15 21.54 22.05 20595 20100723 FII 21.93 21.93 20.67 20.98 25876 20100726 FII 21.03 21.1 20.71 21.1 13590 20100727 FII 21.27 21.4 21.11 21.29 10620 20100728 FII 21.22 21.46 21.12 21.13 7657 20100729 FII 21.23 21.61 21.23 21.53 15506 20100730 FII 21.29 21.59 21.09 21.22 14680 20100802 FII 21.5 21.68 21.2 21.67 31351 20100803 FII 21.67 21.7 21.23 21.24 19218 20100804 FII 21.13 21.55 20.98 21.53 17016 20100805 FII 21.37 21.85 21.36 21.73 16172 20100806 FII 21.49 21.59 21.04 21.35 10262 20100809 FII 21.38 21.725 21.35 21.6 11308 20100810 FII 21.38 21.63 21.3 21.45 8552 20100811 FII 21.06 21.07 20.67 20.75 10544 20100812 FII 20.51 20.82 20.43 20.61 9405 20100813 FII 20.56 20.61 20.38 20.43 5783 20100816 FII 20.33 20.53 20.15 20.17 14647 20100817 FII 20.37 20.82 20.37 20.74 10599 20100819 FII 20.63 20.7 20.2 20.27 6051 20100820 FII 20.13 20.5 20.04 20.49 9936 20090821 FIS 24.67 24.87 24.42 24.85 28481 20090824 FIS 24.94 25.17 24.85 25.01 25462 20090825 FIS 25.08 25.32 24.9 24.98 24190 20090826 FIS 24.96 25.09 24.88 25.06 22744 20090827 FIS 25 25.05 24.4675 24.83 21690 20090828 FIS 25.05 25.05 24.63 24.72 13820 20090831 FIS 24.52 24.75 24.36 24.56 13747 20090901 FIS 24.42 24.835 24.04 24.06 16003 20090902 FIS 23.97 24.1 23.82 23.92 17480 20090903 FIS 23.98 24.35 23.62 24.33 63393 20090904 FIS 24.2 24.4 23.77 24.18 40126 20090909 FIS 24 24.52 23.94 24.48 24391 20090910 FIS 24.48 24.55 24.28 24.35 26143 20090911 FIS 24.34 25.01 24.28 24.82 34233 20090914 FIS 24.71 24.97 24.47 24.85 20690 20090915 FIS 24.89 24.92 24.64 24.84 18093 20090916 FIS 24.83 25.12 24.67 25.12 17019 20090917 FIS 25.07 25.23 24.99 25.05 16106 20090918 FIS 25.12 25.22 24.73 24.93 20846 20090921 FIS 24.82 25.05 24.59 24.93 18805 20090922 FIS 24.97 24.99 24.68 24.73 15484 20090923 FIS 24.71 25.37 24.63 25.16 48178 20090924 FIS 25.23 25.31 24.99 25.3 24016 20090925 FIS 25.3 26 25.22 25.4 46317 20090928 FIS 25.5 25.89 25.44 25.7 19558 20090929 FIS 25.64 25.725 25.36 25.4 23362 20090930 FIS 25.17 25.56 24.935 25.51 36077 20091001 FIS 25.4 25.66 24.85 24.85 291030 20091002 FIS 24.55 24.74 23.96 23.99 57072 20091005 FIS 24.07 24.37 23.89 23.91 55853 20091006 FIS 24.01 24.49 23.93 24.28 45289 20091007 FIS 24.23 24.48 23.93 24.13 37881 20091008 FIS\n\n---\n\n20100726 JNS 10.74 11.01 10.6 10.9 40445 20100727 JNS 10.94 11.08 10.66 10.7 35694 20100728 JNS 10.62 10.79 10.5 10.58 25690 20100729 JNS 10.68 10.95 10.38 10.55 36579 20100730 JNS 10.38 10.65 10.35 10.48 27027 20100802 JNS 10.66 10.88 10.49 10.88 35182 20100803 JNS 10.82 10.92 10.6675 10.69 18053 20100804 JNS 10.76 10.93 10.625 10.91 19306 20100805 JNS 10.76 10.92 10.68 10.91 15024 20100806 JNS 10.75 10.87 10.51 10.7 27226 20100809 JNS 10.8 10.91 10.67 10.79 24824 20100810 JNS 10.64 10.7 10.28 10.35 32777 20100811 JNS 10.13 10.16 9.88 9.88 38485 20100812 JNS 9.74 9.83 9.64 9.7 25766 20100813 JNS 9.63 9.8 9.6 9.75 23862 20100816 JNS 9.7 9.84 9.53 9.78 21572 20100817 JNS 9.91 10.23 9.85 10.06 17651 20100819 JNS 10.1 10.17 9.9 9.97 58803 20100820 JNS 9.97 10.06 9.83 10 30464 20090821 JPM 42.86 43.81 42.53 43.66 428635 20090824 JPM 43.86 44.24 42.95 43.01 403851 20090825 JPM 43.39 44.14 43.3 43.58 348356 20090826 JPM 43.39 43.78 42.92 43.3 319083 20090827 JPM 43.05 43.63 42.54 43.45 289756 20090828 JPM 43.81 43.86 42.51 42.92 272691 20090831 JPM 42.44 43.6 42.06 43.46 322510 20090901 JPM 43.08 43.82 41.56 41.67 514753 20090902 JPM 41.51 42.11 40.75 40.86 358984 20090903 JPM 41.23 42.25 41.11 42.11 350278 20090904 JPM 42.33 42.49 41.79 42.34 218801 20090909 JPM 42.6 43.07 42.39 42.86 290392 20090910 JPM 42.73 43.15 42.2 43.02 251165 20090911 JPM 43.13 43.39 42.48 42.5 272963 20090914 JPM 42.08 43.85 42.01 43.75 289502 20090915 JPM 43.61 44.195 42.55 43.19 499888 20090916 JPM 43.35 44.68 43.21 44.65 387218 20090917 JPM 44.29 45.11 44.2 44.96 357056 20090918 JPM 45.24 45.34 44.7 44.95 394985 20090921 JPM 44.54 44.8 44.22 44.55 240699 20090922 JPM 44.81 46.49 44.48 46.47 411577 20090923 JPM 46.4 46.5 44.98 45.06 344523 20090924 JPM 45.21 45.8 44.26 44.37 422313 20090925 JPM 44.15 44.28 43.34 43.65 310612 20090928 JPM 43.97 44.83 43.69 44.81 258260 20090929 JPM 44.89 45.2 44.43 44.88 239305 20090930 JPM 44.8 44.89 43.43 43.82 409039 20091001 JPM 43.4 43.56 41.36 41.37 505626 20091002 JPM 40.82 42.4 40.53 41.86 430622 20091005 JPM 42.48 43.93 42.35 43.8 343721 20091006 JPM 44.36 45 44.07 44.91 417053 20091007 JPM 44.6 45.82 44.46 45.7 361486 20091008 JPM 46.04 46.44 45.05 45.3 366276 20091009 JPM 45.46 45.94 45.08 45.85 260341 20091012 JPM 46.37 46.42 45.35 46.08 242205 20091013 JPM 45.65 46.03 44.53 45.66 457018 20091014 JPM 47.19 47.47 46.63 47.16 703686 20091015 JPM 46.36 47.32 46.36 47.16 361059 20091016 JPM 46.7 46.88 46 46.06 374589 20091019 JPM 46.42 46.43 45.45 45.98 304153 20091020 JPM 45.81 46.59 45.77 46.03 306188 20091021 JPM 46.02 46.42 44.65 44.65 329915 20091022 JPM 44.92 45.87 44.83 45.71 323987 20091023 JPM 45.7 46.195 44.96 45.23 276394 20091026 JPM 45.12 45.21 43.55 43.82 420854 20091027 JPM 43.99 44.66 43.67 43.9 380863 20091028 JPM 43.73 43.81 42.5 42.68 456794 20091105 JPM 42.6 43.93 42.4 43.87 328932 20091106 JPM 43.14 43.69 42.91 43.48 271449 20091109 JPM 43.93 44.39 43.3 44.35 388454 20091110 JPM 44.14 44.32 43.55 44.17 309801 20091111 JPM 44.34 44.99 43.78 44.32 326748 20091112 JPM 44.08 44.65 43 43.3 343833 20091113 JPM 43.16 43.29 42.36 42.9 366556 20091116 JPM 43.25 43.6089 42.76 43.04 435356 20091117 JPM 42.92 43.19 42.54 43.16 258596 20091118 JPM 43.14 43.5 42.94 43.38 204242 20091119 JPM 43.1 43.18 42.26 42.55 268839 20091120 JPM 42.47 42.74 42.15 42.46 253324 20091123 JPM 42.95 43.64 42.7 43.28 298106 20091124 JPM 43.26 43.28 42.24 42.48 318817 20091125 JPM 42.67 42.67 41.94 42.16 261311 20091127 JPM 40.98 41.9 40.75 41.33 262300 20091130 JPM 41.55 42.65 41.49 42.49 382405 20091201 JPM 42.61 42.71 41.62 42.22 392201 20091202 JPM 42.15 42.15 41.47 41.93 325196 20091203 JPM 42.3 43.09 41.31 41.4 533143 20091204 JPM 42.25 42.51 41.22 41.74 614902 20091207 JPM 41.63 41.96 41.06 41.25 329495 20091208 JPM 41.01 41.4 40.625 41.21 418788 20091209 JPM 41.25 41.51 40.6 41.19 424997 20091210 JPM 41.36 41.56 40.6575 41.27 363829 20091211 JPM 40.99 41.25 40.75 40.96 466160 20091214 JPM 41.01 41.93 40.7 41.77 353407\n\n---\n\nSE 19.36 19.85 19.15 19.85 35495 20100603 SE 19.81 20.16 19.74 20.11 43587 20100604 SE 19.81 19.94 19.27 19.43 44531 20100607 SE 19.51 19.69 19.23 19.23 42711 20100608 SE 19.31 19.79 19.09 19.75 42038 20100609 SE 19.93 20.24 19.63 19.74 36866 20100610 SE 20.1 20.57 20.1 20.55 43411 20100611 SE 20.39 20.63 20.2 20.62 25114 20100614 SE 20.92 21.09 20.59 20.68 35903 20100615 SE 20.9 21.38 20.89 21.38 29638 20100616 SE 21.23 21.45 21.14 21.32 24749 20100617 SE 21.9 21.9 21.2 21.49 27252 20100618 SE 21.53 21.77 21.38 21.69 42768 20100621 SE 21.96 22.12 21.48 21.6 30212 20100622 SE 21.72 21.75 21.11 21.23 36935 20100623 SE 21.18 21.24 20.765 21.02 35207 20100624 SE 20.79 21.11 20.66 20.76 29002 20100625 SE 20.79 21.04 20.62 20.91 45066 20100628 SE 20.9 20.94 20.64 20.83 35523 20100629 SE 20.57 20.68 20.12 20.25 48700 20100630 SE 20.25 20.51 20 20.07 34515 20100701 SE 20.1 20.3 19.67 20.24 59282 20100702 SE 20.27 20.59 20.12 20.18 30495 20100706 SE 20.48 20.6 20.11 20.35 70033 20100707 SE 20.35 20.92 20.35 20.92 42086 20100708 SE 21.1 21.31 20.94 21.23 22899 20100709 SE 21.27 21.36 21.11 21.32 17312 20100712 SE 21.24 21.76 21.19 21.46 29405 20100713 SE 21.66 21.76 21.43 21.47 31924 20100714 SE 21.35 21.44 21.1 21.22 42642 20100715 SE 21.24 21.3 20.95 21.21 37858 20100716 SE 21.15 21.15 20.73 20.83 34138 20100719 SE 20.91 21.09 20.73 20.91 23898 20100720 SE 20.62 21.25 20.56 21.22 44016 20100721 SE 21.28 21.34 20.65 20.83 42265 20100722 SE 21.07 21.36 21.06 21.22 31387 20100723 SE 21.24 21.3 21.03 21.23 35502 20100726 SE 21.16 21.53 21.16 21.49 26866 20100727 SE 21.59 21.65 21.35 21.45 29764 20100728 SE 21.55 21.59 21.09 21.12 49341 20100729 SE 21.28 21.36 20.56 20.69 69609 20100730 SE 20.44 20.84 20.4 20.79 61928 20100802 SE 21.18 21.31 21.04 21.29 36527 20100803 SE 21.22 21.4 21.052 21.24 28767 20100804 SE 21.35 21.58 21.2 21.52 41766 20100805 SE 21.42 21.83 21.2 21.79 37688 20100806 SE 21.64 22 21.59 21.93 44577 20100809 SE 22.07 22.11 21.93 21.96 23707 20100810 SE 21.77 21.89 21.47 21.81 45474 20100811 SE 21.34 21.34 20.92 20.95 31296 20100812 SE 20.71 21.0391 20.65 20.92 27843 20100813 SE 20.9 21.34 20.78 21.27 37654 20100816 SE 21.22 21.22 20.91 21.06 29018 20100817 SE 21.25 21.68 21.16 21.62 33565 20100819 SE 21.36 21.37 20.9 21.04 29220 20100820 SE 20.86 21.05 20.77 20.98 28612 20090821 SEE 18.28 18.85 18.26 18.78 11609 20090824 SEE 18.89 18.97 18.55 18.61 7169 20090825 SEE 18.76 19.44 18.72 19.22 16527 20090826 SEE 19.14 19.43 18.94 19.15 10630 20090827 SEE 19.31 19.31 18.831 19.21 5502 20090828 SEE 19.39 19.42 19.06 19.24 6756 20090831 SEE 19.04 19.08 18.71 18.91 6295 20090901 SEE 18.81 18.91 18.19 18.22 21821 20090902 SEE 18.13 18.27 17.88 18.11 7681 20090903 SEE 18.14 18.44 17.91 18.43 7143 20090904 SEE 18.41 18.67 18.27 18.58 7190 20090909 SEE 18.71 19.31 18.57 19.05 11468 20090910 SEE 18.97 19.16 18.67 19.15 7279 20090911 SEE 19.13 19.19 18.75 19.05 7919 20090914 SEE 19.51 20.23 19.38 20.16 17063 20090915 SEE 20.35 20.63 20.2 20.52 10954 20090916 SEE 20.58 20.84 20.25 20.75 7728 20090917 SEE 20.64 20.92 20.3 20.43 11631 20090918 SEE 20.78 20.78 20.36 20.58 9983 20090921 SEE 20.36 20.46 20.15 20.36 6754 20090922 SEE 20.48 20.5 20.27 20.36 4014 20090923 SEE 20.46 20.46 19.93 19.96 5687 20090924 SEE 20.01 20.1 19.53 19.58 7198 20090925 SEE 19.54 19.7 19.23 19.41 6145 20090928 SEE 19.54 19.92 19.4 19.81 5098 20090929 SEE 19.62 20.07 19.62 19.89 7243 20090930 SEE 19.95 20 19.36 19.63 8562 20091001 SEE 19.62 19.62 18.89 18.95 11841 20091002 SEE 18.91 19.01 18.63 18.78 10269 20091005 SEE 18.84 19.23 18.73 19.2 9575 20091006 SEE 19.42 19.53 18.91 19.18 10580 20091007 SEE 19.08 19.38 18.99 19.38 7803 20091008 SEE 19.56 19.83 19.43 19.68 8867 20091009 SEE 19.72 19.8 19.48 19.8 4324 20091012 SEE 19.81 20.05 19.76 19.82 3569 20091013 SEE 19.8 20.1 19.75 20.04 7041 20091014 SEE 20.27 20.54 20.14 20.4 7739 20091015 SEE 20.24 20.5 20.15 20.48 7890 20091016 SEE 20.4 20.45 19.98 20.22 6534 20091019 SEE 20.21 20.59 20.14 20.55 6137\n\n---\n\nSTI 23.79 23.86 23.3 23.64 43873 20100302 STI 23.67 24.72 23.67 24.43 76578 20100303 STI 24.51 24.64 24.08 24.16 39229 20100304 STI 24.17 24.44 24 24.38 42616 20100305 STI 24.45 25.09 24.35 25.06 49582 20100308 STI 25.02 25.9 24.96 25.64 72613 20100309 STI 25.35 26.45 25.07 25.83 105301 20100310 STI 26.02 27.25 25.92 26.49 126045 20100311 STI 26.69 27.13 26.28 27.08 66549 20100312 STI 27.55 28 26.76 26.86 89868 20100315 STI 26.72 27.39 26.72 26.99 72418 20100316 STI 27.15 27.45 26.81 27.38 68034 20100317 STI 27.3 28.39 27.27 28.09 75447 20100318 STI 28 28.13 27.12 27.38 63822 20100319 STI 27.61 27.8 26.89 27.18 69210 20100322 STI 26.39 27.15 26.39 27.09 71365 20100323 STI 26.93 27.09 26.16 26.87 78178 20100324 STI 26.67 27.3 26.67 27.26 60199 20100325 STI 27.54 27.65 26.54 26.57 84336 20100326 STI 26.71 27.07 26.25 26.5 83557 20100329 STI 26.7 26.76 26.18 26.34 32070 20100330 STI 26.35 26.75 26.15 26.34 34052 20100331 STI 26.21 26.9 26.15 26.79 56231 20100401 STI 26.97 27.23 26.84 27.16 49725 20100405 STI 27.3 27.789 27.05 27.74 63262 20100406 STI 27.59 28.97 27.43 28.71 81300 20100407 STI 29 29.41 28.34 28.53 79169 20100408 STI 28.18 28.6 27.72 28.56 67171 20100409 STI 28.7 28.82 28.24 28.65 40028 20100412 STI 28.91 29.64 28.79 29.44 69261 20100413 STI 29.28 29.28 28.71 29.02 54424 20100414 STI 29.31 30.29 29.17 30.28 81119 20100415 STI 30.26 30.42 29.59 29.77 68068 20100416 STI 29.64 29.64 27.64 28.48 148521 20100419 STI 28.12 29.05 27.98 28.97 88457 20100420 STI 29.01 30.29 28.76 30.19 81396 20100421 STI 29.67 31.42 29.29 29.72 134911 20100422 STI 29.24 29.46 28.4 29.32 97762 20100423 STI 29.4 29.78 29.07 29.44 64657 20100426 STI 29.43 29.61 28.24 28.37 50900 20100427 STI 28.07 29.3 27.68 27.79 113775 20100428 STI 28.4 29.45 28.37 29.12 103294 20100429 STI 29.51 29.89 28.93 29.7 59490 20100430 STI 29.49 29.97 29.41 29.6 62068 20100503 STI 29.87 30.49 29.49 30.44 54371 20100504 STI 30.04 30.19 28.96 29.15 54841 20100505 STI 28.79 30.1 28.31 29.4 51980 20100506 STI 29.26 29.81 26.29 28.04 107360 20100507 STI 28.1 28.65 26.95 27.46 99463 20100510 STI 28.97 29.65 28.32 29.1 70341 20100511 STI 28.52 30.67 28.52 30.45 98474 20100512 STI 30.58 31.92 30.43 31.85 95867 20100513 STI 31.67 32.02 31.22 31.27 59491 20100514 STI 30.78 30.97 29.29 29.82 84969 20100517 STI 29.8 30.25 28.88 29.88 70270 20100518 STI 30.19 30.22 27.47 28.03 150965 20100519 STI 27.67 28.65 27 27.54 105986 20100520 STI 26.82 27.22 26.15 26.21 116830 20100521 STI 25.55 27.27 25.38 26.99 117513 20100524 STI 26.21 26.88 25.34 25.4 89431 20100525 STI 24.58 26.32 24.39 26.31 91033 20100526 STI 26.84 27.06 26.1 26.56 91803 20100527 STI 27.12 27.69 26.44 27.61 76656 20100528 STI 27.58 27.73 26.67 26.95 53483 20100601 STI 26.58 27.19 26.1 26.17 64789 20100602 STI 26.32 27.26 26.07 27.26 73428 20100603 STI 27.52 27.59 26.68 26.9 50141 20100604 STI 26.23 26.38 24.92 25.03 106240 20100607 STI 25.16 25.52 24.41 24.43 71121 20100608 STI 24.61 25.26 24.3 25.11 97667 20100609 STI 25.4 25.53 24.64 24.73 69384 20100610 STI 25.1 25.92 24.94 25.83 63728 20100611 STI 25.39 25.92 25.16 25.89 50285 20100614 STI 25.98 26.32 25.51 25.69 48241 20100615 STI 26.13 26.44 25.81 26.37 62610 20100616 STI 26.23 26.5 26 26.36 58339 20100617 STI 26.28 26.57 25.97 26.24 45282 20100618 STI 26.32 26.54 26.09 26.2 53170 20100621 STI 26.62 26.63 25.71 25.85 57877 20100622 STI 25.9 25.93 25.19 25.24 64681 20100623 STI 25.3 25.71 24.66 25.27 57314 20100624 STI 25.08 25.14 24.28 24.37 74816 20100625 STI 24.74 25.97 24.51 25.51 102149 20100628 STI 25.67 25.7 24.92 25.16 55209 20100629 STI 24.68 24.81 23.28 23.44 102824 20100630 STI 23.5 24.04 23.12 23.3 77041 20100701 STI 23.26 23.5 21.79 22.8 138683 20100702 STI 23.03 23.03 22.11 22.44 65961 20100706 STI 22.97 23 22.37 22.62 93525 20100707 STI 22.84 24.56 22.71 24.48 141792 20100708 STI 24.96 24.96 24.05 24.67 82240 20100709 STI 24.55 25.54 24.46 25.46 54188 20100712 STI 25.24 25.48 24.8 25.18 33142 20100713 STI 25.54 26.365 25.5 26.18 63045 20100714\n\n---\n\n4.66 71357 20090901 THC 4.65 4.7 4.37 4.39 85639 20090902 THC 4.36 4.45 4.29 4.41 61550 20090903 THC 4.46 4.5 4.38 4.49 38656 20090904 THC 4.51 4.89 4.49 4.81 93642 20090909 THC 4.75 5.13 4.74 5.09 81474 20090910 THC 5.1 5.46 5 5.41 93595 20090911 THC 5.45 5.51 5.28 5.45 69269 20090914 THC 5.83 6.07 5.71 5.75 390102 20090915 THC 5.8 5.85 5.6 5.74 154724 20090916 THC 5.8 5.95 5.62 5.95 126437 20090917 THC 5.94 6.02 5.73 5.76 97862 20090918 THC 5.75 5.85 5.61 5.61 87967 20090921 THC 5.6 5.93 5.6 5.85 102194 20090922 THC 5.81 5.98 5.77 5.9 68500 20090923 THC 5.92 5.97 5.77 5.85 60627 20090924 THC 5.87 5.87 5.48 5.53 79313 20090925 THC 5.43 5.57 5.35 5.44 49561 20090928 THC 5.45 5.89 5.44 5.83 93893 20090929 THC 5.85 5.96 5.76 5.79 53806 20090930 THC 5.79 5.89 5.46 5.88 113832 20091001 THC 5.85 5.87 5.45 5.47 83402 20091002 THC 5.27 5.45 5.21 5.36 74425 20091005 THC 5.47 5.7 5.33 5.61 78056 20091006 THC 5.68 5.78 5.53 5.65 71170 20091007 THC 5.65 5.77 5.64 5.67 38568 20091008 THC 5.79 6.02 5.74 5.95 124838 20091009 THC 5.96 6.1 5.832 5.98 77189 20091012 THC 6.01 6.01 5.91 5.99 73281 20091013 THC 6.05 6.05 5.83 5.92 55792 20091014 THC 5.95 6 5.86 6 48291 20091015 THC 6 6.03 5.92 6 84811 20091016 THC 5.96 6.03 5.8 5.94 87231 20091019 THC 5.93 6.23 5.93 6.16 132850 20091020 THC 6.2 6.36 6.09 6.24 94913 20091021 THC 6.24 6.39 6.1 6.13 85477 20091022 THC 6.2 6.26 6.03 6.08 90436 20091023 THC 6.13 6.19 5.75 5.79 99769 20091026 THC 5.81 5.92 5.38 5.56 111755 20091027 THC 5.5 5.59 5.21 5.46 124860 20091028 THC 5.4 5.46 5.07 5.11 107471 20091105 THC 5.19 5.35 5.15 5.23 70811 20091106 THC 5.18 5.28 5.04 5.11 62519 20091109 THC 5.25 5.3 5.15 5.3 55132 20091110 THC 5.33 5.54 5.31 5.44 83917 20091111 THC 5.48 5.7 5.48 5.58 58772 20091112 THC 5.53 5.71 5.48 5.5 50286 20091113 THC 5.52 5.63 5.47 5.56 40889 20091116 THC 5.59 5.69 5.57 5.6 37777 20091117 THC 5.55 5.585 5.44 5.47 55453 20091118 THC 5.46 5.49 5.25 5.29 61717 20091119 THC 5.23 5.35 5.13 5.26 60500 20091120 THC 5.17 5.3 5.16 5.27 35835 20091123 THC 5.36 5.41 5.15 5.19 47571 20091124 THC 5.16 5.19 4.91 5.1 84287 20091125 THC 5.1 5.1 5.02 5.09 37874 20091127 THC 4.97 5.02 4.84 4.95 35892 20091130 THC 4.99 5.01 4.52 4.55 138362 20091201 THC 4.65 4.87 4.59 4.77 162599 20091202 THC 4.65 4.75 4.55 4.73 111415 20091203 THC 4.93 5.1 4.83 4.87 130171 20091204 THC 4.98 5.05 4.7 4.75 93756 20091207 THC 4.78 4.95 4.7 4.9 78440 20091208 THC 4.86 4.9 4.75 4.79 52078 20091209 THC 4.83 4.855 4.65 4.76 57006 20091210 THC 4.78 4.86 4.75 4.86 42917 20091211 THC 4.9 4.91 4.76 4.81 44567 20091214 THC 4.83 4.95 4.8 4.92 42372 20091215 THC 4.9 5.26 4.89 5.12 87824 20091216 THC 5.19 5.35 5.16 5.26 64230 20091217 THC 5.15 5.28 5.01 5.1 92451 20091218 THC 5.11 5.19 4.91 4.91 113831 20091221 THC 4.95 5.16 4.91 5.07 106673 20091222 THC 5.13 5.35 5.11 5.32 94778 20091223 THC 5.5 5.8 5.45 5.52 146551 20091224 THC 5.78 5.8 5.46 5.62 58255 20091228 THC 5.72 5.74 5.47 5.5 55243 20091229 THC 5.44 5.48 5.21 5.33 85768 20091230 THC 5.26 5.28 5.14 5.2 57086 20091231 THC 5.21 5.52 5.21 5.39 91387 20100104 THC 5.44 5.56 5.39 5.45 53531 20100105 THC 5.92 6.16 5.91 6 268586 20100106 THC 6.03 6.05 5.84 5.9 79010 20100107 THC 6.07 6.15 5.98 6.01 94128 20100108 THC 6.01 6.28 6.01 6.25 103279 20100111 THC 6.36 6.38 6.11 6.14 52282 20100112 THC 6.03 6.08 5.86 5.91 71552 20100113 THC 5.99 6.28 5.96 6.25 97055 20100114 THC 6.29 6.44 6.15 6.29 99685 20100115 THC 6.26 6.34 6.06 6.07 81164 20100119 THC 6.1 6.18 5.69 5.86 160252 20100120 THC 5.74 5.8 5.6 5.65 105644 20100121 THC 5.68 5.73 5.44 5.45 90310 20100122 THC 5.43 5.53 5.17 5.19 155699 20100125 THC 5.26 5.35 5.17 5.29 82943 20100126 THC 5.2 5.65 5.2 5.53 128071 20100127 THC 5.52 5.56 5.31 5.39 67428 20100128 THC 5.48 5.5 5.13 5.16 93648 20100129 THC 5.24 5.59 5.17 5.54 240520 20100201 THC 5.51 5.58 5.3 5.49 123133 20100202 THC 5.53 5.62 5.42 5.59 75041 20100203 THC 5.58 5.69 5.47 5.52 51625 20100204 THC 5.43 5.46 5.18 5.2 107954 20100205 THC 5.19 5.2 4.95 5.1 101381 20100208\n\n---\n\n77.69 21095 20090826 BCR 77.44 78.55 77.19 78.24 12723 20090827 BCR 78.21 79.19 77.83 78.99 10243 20090828 BCR 80.26 80.76 78.99 80.31 14241 20090831 BCR 80.07 80.78 79.55 80.58 17274 20090901 BCR 80.4 81.21 79.04 80.49 16996 20090902 BCR 80 81.16 80 80.63 15551 20090903 BCR 80.4 80.99 79.7 80.53 10418 20090904 BCR 80.68 80.68 79.65 80.45 9047 20090909 BCR 79.12 81.26 79.12 80.81 7811 20090910 BCR 81.12 81.16 80.19 80.75 10287 20090911 BCR 80.8 81.33 80.4 80.51 8658 20090914 BCR 80.5 81.52 80.27 81.33 6909 20090915 BCR 81.06 82.98 80.9 82.56 12022 20090916 BCR 82.43 82.83 81.18 81.29 9082 20090917 BCR 81.02 81.27 80.45 80.45 7147 20090918 BCR 80.64 80.74 80.015 80.15 10987 20090921 BCR 80 81.13 79.92 80.09 6318 20090922 BCR 80.12 80.12 79.17 79.44 6232 20090923 BCR 79.71 79.71 78.56 78.56 7574 20090924 BCR 78.45 79.04 77.91 78.1 8744 20090925 BCR 77.94 78.66 77.8 78.06 5999 20090928 BCR 78.22 79.22 78.1 78.75 4991 20090929 BCR 78.75 78.96 78 78.41 6177 20090930 BCR 78.39 78.94 77.72 78.61 8141 20091001 BCR 78.48 78.57 77.53 77.53 8495 20091002 BCR 77.35 77.66 76.75 77.39 6563 20091005 BCR 77.31 77.31 76.45 77.06 8768 20091006 BCR 77.2 77.83 76.29 77.27 6275 20091007 BCR 76.98 77.435 76.56 77.18 6491 20091008 BCR 77.17 78.47 77.17 78.08 6465 20091009 BCR 77.93 78.39 77.772 77.94 5321 20091012 BCR 77.96 78.01 77.44 77.48 5918 20091013 BCR 77.2 77.75 76.86 77.64 6688 20091014 BCR 77.4 77.97 77.24 77.59 10474 20091015 BCR 77.48 77.67 76.88 77.46 10559 20091016 BCR 77.01 77.05 76.14 76.19 12299 20091019 BCR 76.775 77.06 76.19 76.95 8291 20091020 BCR 77 77.03 75.57 75.74 9598 20091021 BCR 76.2 76.56 75.24 75.26 16804 20091022 BCR 74.8 77.37 73.99 76.88 31428 20091023 BCR 76.56 77.1 76.275 76.74 11142 20091026 BCR 76.52 77.03 75.4 75.78 11142 20091027 BCR 76.2 76.25 75.41 75.93 10544 20091028 BCR 76.12 77.16 75.52 75.56 9644 20091105 BCR 77.54 78.125 77.41 77.98 8162 20091106 BCR 77.74 78.95 77.4 78.39 8279 20091109 BCR 78.69 79.86 78.41 79.84 6186 20091110 BCR 79.57 80.73 79.57 80.66 7606 20091111 BCR 80.71 81.07 80.47 80.9 6023 20091112 BCR 80.99 80.99 79.65 80.16 4718 20091113 BCR 80.21 81.11 80.17 80.76 7143 20091116 BCR 80.805 81.86 80.74 81.65 5404 20091117 BCR 81.81 81.91 81.45 81.84 6159 20091118 BCR 81.63 82.39 81.4 81.95 5039 20091119 BCR 81.81 82.22 80.9 81.89 7751 20091120 BCR 81.88 81.88 80.45 80.72 9399 20091123 BCR 80.91 81.55 80.75 81 7686 20091124 BCR 80.9 82.02 80.75 82.01 13398 20091125 BCR 81.87 82.29 81.45 82 5635 20091127 BCR 80.69 82.39 80.35 81.86 3830 20091130 BCR 82.14 82.43 81.43 82.21 11490 20091201 BCR 82.86 83.2 82.48 83.05 8943 20091202 BCR 83.09 84.01 82.97 83.52 6816 20091203 BCR 83.18 83.74 82.75 82.87 6964 20091204 BCR 83.63 84.07 82.41 83.04 7177 20091207 BCR 83.16 83.59 82.69 82.82 6870 20091208 BCR 82.42 82.54 81.73 81.8 10052 20091209 BCR 81.66 82.12 81.27 81.8 9702 20091210 BCR 82.24 83.46 82.12 83.12 9578 20091211 BCR 83.46 83.86 82.87 83.05 7115 20091214 BCR 83.7 84.23 83.35 83.62 7880 20091215 BCR 85.21 85.21 84.18 85.02 18761 20091216 BCR 85.43 85.49 84.88 85.05 11672 20091217 BCR 84.49 84.953 84.15 84.16 7532 20091218 BCR 76.65 79.8 76.37 78.49 64485 20091221 BCR 78.79 79.77 78.25 78.64 20423 20091222 BCR 78.95 79.49 78.51 79.27 8695 20091223 BCR 78.99 79.25 78.59 78.8 6554 20091224 BCR 79.11 79.11 78.8 79.08 1925 20091228 BCR 79 79.11 78.67 78.97 5081 20091229 BCR 79.14 79.22 78.77 79 5138 20091230 BCR 78.71 79.35 78.69 79.26 4997 20091231 BCR 79.15 79.16 77.75 77.9 11547 20100104 BCR 78.59 78.94 77.85 78.68 13717 20100105 BCR 78.5 79.42 78.46 79.35 10935 20100106 BCR 79.37 79.37 78.68 79.01 7917 20100107 BCR 78.87 80.28 78.69 80.13 12870 20100108 BCR 79.89 80.54 79.08 80.51 8893 20100111 BCR 80.66 81.97 80.63 81.26 10574 20100112 BCR 81.12 81.18 79.82 80.46 7574 20100113 BCR 80.96 83.02 80.67 82.63 21721 20100114 BCR 82.61 83.56 82.29 83.55 10289 20100115 BCR 83.5 83.545 81.87 82.62 10413 20100119 BCR 83.21 84 82.83 83.83 8761 20100120 BCR 83.79 83.79 81.66 82.4 9747 20100121 BCR 82.18\n\n---\n\nTHC 5.51 5.58 5.3 5.49 123133 20100202 THC 5.53 5.62 5.42 5.59 75041 20100203 THC 5.58 5.69 5.47 5.52 51625 20100204 THC 5.43 5.46 5.18 5.2 107954 20100205 THC 5.19 5.2 4.95 5.1 101381 20100208 THC 5.07 5.15 4.93 4.96 102280 20100209 THC 5.07 5.18 5 5.15 64560 20100210 THC 5.11 5.17 5.06 5.08 43941 20100211 THC 5.07 5.27 5.04 5.24 43546 20100212 THC 5.18 5.26 5.12 5.21 67719 20100216 THC 5.31 5.32 5.17 5.32 57902 20100217 THC 5.35 5.59 5.35 5.55 75280 20100218 THC 5.52 5.75 5.51 5.64 70371 20100219 THC 5.6 5.67 5.55 5.59 91639 20100222 THC 5.64 5.67 5.52 5.58 105614 20100223 THC 5.33 5.34 4.92 5.04 295632 20100224 THC 5.06 5.17 5.02 5.07 168689 20100225 THC 5.01 5.07 4.94 5.03 94462 20100226 THC 5.03 5.3 4.97 5.27 131615 20100301 THC 5.28 5.34 5.22 5.27 77962 20100302 THC 5.27 5.38 5.15 5.38 94704 20100303 THC 5.4 5.47 5.3 5.38 82062 20100304 THC 5.38 5.47 5.32 5.45 76306 20100305 THC 5.45 5.55 5.401 5.51 52013 20100308 THC 5.55 5.59 5.46 5.5 58912 20100309 THC 5.46 5.47 5.34 5.38 98006 20100310 THC 5.33 5.41 5.18 5.37 139540 20100311 THC 5.35 5.38 5.25 5.37 63085 20100312 THC 5.37 5.44 5.3 5.39 43987 20100315 THC 5.34 5.77 5.3 5.73 144438 20100316 THC 5.72 5.78 5.61 5.72 87100 20100317 THC 5.58 5.81 5.58 5.66 101585 20100318 THC 5.65 5.89 5.61 5.66 135163 20100319 THC 5.69 5.8 5.64 5.75 106426 20100322 THC 6.09 6.38 6.01 6.27 341340 20100323 THC 6.41 6.46 6.16 6.3 193157 20100324 THC 6.26 6.26 5.92 5.97 149926 20100325 THC 6.08 6.08 5.8 5.82 158310 20100326 THC 5.91 5.96 5.75 5.81 80851 20100329 THC 5.87 5.95 5.83 5.88 70382 20100330 THC 5.93 5.95 5.71 5.73 84287 20100331 THC 5.7 5.78 5.58 5.72 64926 20100401 THC 5.8 5.96 5.8 5.96 84686 20100405 THC 5.92 6.05 5.88 5.93 97605 20100406 THC 5.84 5.94 5.8 5.83 66200 20100407 THC 5.86 5.95 5.8 5.94 92670 20100408 THC 5.87 6.02 5.82 5.95 81046 20100409 THC 5.94 6.06 5.94 5.99 77640 20100412 THC 5.98 6.14 5.98 6.06 68495 20100413 THC 6.01 6.05 5.92 6.01 69714 20100414 THC 5.99 6.04 5.945 5.96 97224 20100415 THC 5.96 6 5.85 5.9 95002 20100416 THC 5.88 5.94 5.73 5.8 126150 20100419 THC 5.78 5.94 5.75 5.89 112406 20100420 THC 5.98 6.31 5.93 6.28 175793 20100421 THC 6.29 6.38 6.16 6.21 83620 20100422 THC 6.2 6.41 6.06 6.39 104246 20100423 THC 6.41 6.43 6.31 6.34 65224 20100426 THC 6.31 6.38 6.15 6.15 70929 20100427 THC 6.13 6.37 6.1 6.12 132748 20100428 THC 6.14 6.305 6.13 6.2 83671 20100429 THC 6.21 6.42 6.19 6.38 72822 20100430 THC 6.4 6.44 6.15 6.25 105655 20100503 THC 6.23 6.36 6.2 6.34 57507 20100504 THC 6.13 6.17 5.83 5.87 135423 20100505 THC 5.82 5.9 5.66 5.73 116988 20100506 THC 5.72 5.86 5.24 5.58 167273 20100507 THC 5.55 5.62 5.2875 5.32 116544 20100510 THC 5.61 5.71 5.54 5.61 82703 20100511 THC 5.56 5.75 5.55 5.68 59653 20100512 THC 5.69 5.77 5.51 5.77 106669 20100513 THC 5.75 5.91 5.67 5.7 116107 20100514 THC 5.65 5.7 5.52 5.6 86621 20100517 THC 5.6 5.74 5.4 5.63 87592 20100518 THC 5.64 5.7 5.39 5.52 89489 20100519 THC 5.45 5.54 5.32 5.37 76546 20100520 THC 5.34 5.44 5.18 5.18 78499 20100521 THC 5.12 5.49 5.01 5.37 164178 20100524 THC 5.48 5.68 5.39 5.54 124045 20100525 THC 5.36 5.5 5.26 5.43 107079 20100526 THC 5.49 5.65 5.45 5.51 96922 20100527 THC 5.63 5.8 5.6 5.8 61255 20100528 THC 5.79 5.79 5.63 5.72 79861 20100601 THC 5.54 5.6 4.69 4.72 580202 20100602 THC 4.9 5.165 4.85 5.09 292668 20100603 THC 5.04 5.09 4.78 5.03 210342 20100604 THC 4.94 5.13 4.89 4.92 155640 20100607 THC 5 5.34 4.76 5.11 297103 20100608 THC 5.07 5.17 4.67 4.8 253261 20100609 THC 4.83 4.97 4.76 4.78 154854 20100610 THC 4.94 5.04 4.84 5.04 153010 20100611 THC 4.98 5.07 4.94 5.07 107481 20100614 THC 5.15 5.225 4.97 5.06 127975 20100615 THC 5.24 5.28 5.0275 5.2 242921 20100616 THC 5.14 5.22 5.09 5.16 68734 20100617 THC 5.13 5.18 4.93 5.02 141527 20100618 THC 5.02 5.04 4.85 4.9 162205 20100621 THC 4.97 4.99 4.71 4.74 125639 20100622 THC 4.74 4.83 4.68 4.7 85307 20100623 THC 4.71 4.84 4.6 4.77 119881 20100624 THC 4.76 4.8 4.6 4.62 122849 20100625 THC 4.64 4.72 4.58 4.71 87402 20100628 THC 4.72 4.82 4.65\n\n---\n\n10.6 10.66 60433 20091127 DHI 10.26 10.62 10.05 10.54 32793 20091130 DHI 10.45 10.61 10.17 10.28 76018 20091201 DHI 10.4 10.53 10.22 10.42 61511 20091202 DHI 10.33 10.51 9.78 10.04 155602 20091203 DHI 10.14 10.16 9.93 10 88916 20091204 DHI 10.16 10.36 9.89 10.1 87459 20091207 DHI 9.99 10.2 9.865 9.9 90100 20091208 DHI 9.81 10.06 9.71 9.85 62465 20091209 DHI 9.97 9.97 9.69 9.84 48746 20091210 DHI 9.93 10.07 9.84 9.89 60657 20091211 DHI 9.92 9.9785 9.71 9.86 41815 20091214 DHI 9.98 10.09 9.73 10.07 38322 20091215 DHI 10.07 10.17 9.78 9.81 50547 20091216 DHI 9.94 10.37 9.87 10.29 74415 20091217 DHI 10.17 10.34 10.08 10.25 60182 20091218 DHI 10.31 10.53 10.21 10.53 114526 20091221 DHI 10.79 10.8 10.5 10.74 63023 20091222 DHI 10.76 11.17 10.71 11.15 93599 20091223 DHI 11.28 11.33 10.99 11.12 79780 20091224 DHI 11.09 11.14 11.05 11.12 15890 20091228 DHI 11.14 11.25 10.84 10.96 53858 20091229 DHI 10.97 11.12 10.75 10.93 49061 20091230 DHI 10.79 11.1 10.76 10.99 40139 20091231 DHI 10.94 11.03 10.83 10.87 29864 20100104 DHI 10.96 11.18 10.87 11.16 57990 20100105 DHI 11.1 11.59 10.945 11.56 102544 20100106 DHI 11.45 11.76 11.39 11.66 84102 20100107 DHI 11.94 12.6333 11.92 12.27 138087 20100108 DHI 12.12 12.31 12.04 12.17 57206 20100111 DHI 12.29 12.32 12.02 12.24 37460 20100112 DHI 12.09 12.225 11.85 12.21 59820 20100113 DHI 12.24 12.57 12.04 12.42 62783 20100114 DHI 12.33 12.56 12.23 12.25 43447 20100115 DHI 12.19 12.38 11.94 12.14 46860 20100119 DHI 12.1 12.495 12.09 12.33 44561 20100120 DHI 12.16 12.32 12.08 12.13 51945 20100121 DHI 12.11 12.17 11.52 11.55 72756 20100122 DHI 11.52 11.86 11.11 11.2 117475 20100125 DHI 11.3 11.58 11.17 11.37 60310 20100126 DHI 11.25 11.59 11.2 11.29 72662 20100127 DHI 11.21 11.72 11.17 11.67 90993 20100128 DHI 11.78 12.04 11.53 11.79 94370 20100129 DHI 11.96 12.12 11.77 11.79 67884 20100201 DHI 11.83 12.04 11.63 11.91 68157 20100202 DHI 12.79 13.355 12.23 13.21 288143 20100203 DHI 13.27 13.305 12.81 13.25 117121 20100204 DHI 13.03 13.34 12.94 13.21 137177 20100205 DHI 13.08 13.14 12.16 12.67 143734 20100208 DHI 12.72 13.26 12.47 12.92 86915 20100209 DHI 13.08 13.16 12.605 12.98 84932 20100210 DHI 12.97 13.07 12.59 12.85 73130 20100211 DHI 12.85 13.22 12.695 13.12 65258 20100212 DHI 13.25 13.42 12.96 13.07 83256 20100216 DHI 13.3 13.33 13.05 13.22 45824 20100217 DHI 13.43 13.53 12.94 13.12 69247 20100218 DHI 12.98 13.03 12.69 12.78 72085 20100219 DHI 12.74 13 12.74 12.95 77251 20100222 DHI 13 13.09 12.77 12.92 62027 20100223 DHI 12.88 12.975 12.43 12.57 95564 20100224 DHI 12.63 12.65 12.04 12.34 94375 20100225 DHI 12.08 12.35 11.96 12.35 60017 20100226 DHI 12.37 12.45 12.02 12.36 52503 20100301 DHI 12.37 12.585 12.37 12.56 38737 20100302 DHI 12.66 12.72 12.4 12.47 38059 20100303 DHI 12.56 12.8 12.465 12.57 54716 20100304 DHI 12.59 12.72 12.31 12.49 44049 20100305 DHI 12.58 12.95 12.55 12.87 64969 20100308 DHI 12.87 12.99 12.79 12.96 28706 20100309 DHI 12.91 13.17 12.83 13.09 50213 20100310 DHI 13.1 13.23 12.9 13.01 50131 20100311 DHI 12.95 12.98 12.73 12.96 43454 20100312 DHI 12.99 13.01 12.78 13 45720 20100315 DHI 12.98 13.029 12.64 12.84 35303 20100316 DHI 12.8 13.15 12.6 13.03 50426 20100317 DHI 13.05 13.17 12.79 12.89 48752 20100318 DHI 12.93 12.99 12.66 12.76 29390 20100319 DHI 12.81 12.93 12.5 12.51 55931 20100322 DHI 12.4 12.79 12.37 12.75 33722 20100323 DHI 12.83 12.88 12.65 12.76 51373 20100324 DHI 12.95 13.07 12.76 12.85 52724 20100325 DHI 12.91 13.4 12.91 12.97 61700 20100326 DHI 13.03 13.38 12.97 13.13 44007 20100329 DHI 13.21 13.23 12.74 13.03 50741 20100330 DHI 12.99 13.11 12.72 12.8 40758 20100331 DHI 12.73 12.87 12.53 12.6 54078 20100401 DHI 12.72 12.81 12.4 12.51 40378 20100405 DHI 12.62 12.79 12.46 12.59 43647 20100406 DHI 12.52 12.59 12.32 12.52 55899 20100407 DHI 12.54 12.55 11.86 11.93 115183 20100408 DHI 11.9 12.03 11.75 12.01 79148 20100409 DHI 12.04 12.185 11.98 12.14 38701 20100412 DHI 12.19 12.24 11.89 12.03 67469 20100413 DHI 12.04 12.27 12.01 12.18 69399 20100414 DHI 12.25\n\n---\n\n25.34 99365 20091111 CHK 25.65 25.81 25.02 25.18 128210 20091112 CHK 25.17 25.69 24.6 24.71 166518 20091113 CHK 24.87 25.2 24.57 25.03 132923 20091116 CHK 25.27 25.61 24.96 25.14 154597 20091117 CHK 25.1 25.12 24.2 24.3 198765 20091118 CHK 24.6 24.67 23.8 24.08 183387 20091119 CHK 23.91 23.94 23.19 23.38 141923 20091120 CHK 23.2 23.37 22.77 23.03 130400 20091123 CHK 23.63 23.79 23.1 23.2 134124 20091124 CHK 23.19 23.69 22.775 23.65 140035 20091125 CHK 23.82 24.95 23.43 24.86 205862 20091127 CHK 23.82 24.49 23.5 24.17 106310 20091130 CHK 24 24.62 23.7 23.92 167220 20091201 CHK 24.29 24.58 24 24.1 120845 20091202 CHK 24.05 24.05 23.19 23.4 176892 20091203 CHK 23.55 23.55 22.96 23.03 134563 20091204 CHK 23.45 23.55 22.2 22.57 257800 20091207 CHK 22.75 23.37 22.65 22.8 165841 20091208 CHK 22.92 22.98 22.42 22.55 154343 20091209 CHK 22.82 22.86 22.06 22.44 137203 20091210 CHK 22.66 23.3 22.5 23.17 183380 20091211 CHK 23.28 23.46 22.9 23.03 124207 20091214 CHK 24.8 24.81 24.18 24.37 332270 20091215 CHK 24.48 24.8 24.33 24.54 159876 20091216 CHK 24.82 25.0995 24.61 24.91 139990 20091217 CHK 24.78 25.27 24.42 25 175842 20091218 CHK 25.5 26.38 25.5 26.06 256946 20091221 CHK 26.69 26.75 26.36 26.38 133205 20091222 CHK 26.7 26.93 26.41 26.81 118373 20091223 CHK 27.02 27.49 26.84 27.32 94445 20091224 CHK 27.57 28.08 27.53 27.83 90637 20091228 CHK 28.16 28.23 27.22 27.59 148475 20091229 CHK 27.56 27.9 26.71 26.73 146376 20091230 CHK 26.4 26.74 26.27 26.36 89524 20091231 CHK 26.36 26.58 25.78 25.88 97606 20100104 CHK 27.43 28.11 26.92 28.09 294671 20100105 CHK 28.28 29.12 28.2 28.97 271528 20100106 CHK 29.21 29.22 28.53 28.65 151891 20100107 CHK 28.63 28.8 28.18 28.72 131613 20100108 CHK 28.39 28.92 28.05 28.91 110302 20100111 CHK 28.98 28.98 27.73 28 142301 20100112 CHK 27.51 27.7 27.17 27.58 129900 20100113 CHK 27.42 27.94 26.92 27.82 105042 20100114 CHK 28 28.38 27.52 27.67 158822 20100115 CHK 27.52 28.09 27.25 27.91 172501 20100119 CHK 27.67 28.26 27.5 28.21 104549 20100120 CHK 27.8 27.87 27.36 27.66 100372 20100121 CHK 27.91 28.25 27.17 27.18 164934 20100122 CHK 27.05 27.68 26.48 26.62 159938 20100125 CHK 26.88 27.36 26.72 26.96 93468 20100126 CHK 26.65 27.12 26.32 26.53 100996 20100127 CHK 26.48 26.54 25.26 25.93 171954 20100128 CHK 25.63 25.86 25.03 25.51 179526 20100129 CHK 25.7 26.07 24.64 24.78 153138 20100201 CHK 25.08 25.91 25.08 25.86 106248 20100202 CHK 26.02 26.33 25.59 26.25 79747 20100203 CHK 26.16 26.44 25.68 25.83 70494 20100204 CHK 25.29 25.34 24.13 24.18 148629 20100205 CHK 24.25 24.82 23.56 24.52 168326 20100208 CHK 24.71 24.97 24.151 24.24 98693 20100209 CHK 24.68 24.87 24.02 24.51 115952 20100210 CHK 24.36 24.67 23.85 24.4 79591 20100211 CHK 24.39 25.17 24.25 25.13 95451 20100212 CHK 24.64 25.16 24.31 24.96 104322 20100216 CHK 25.56 25.99 25.4811 25.83 90933 20100217 CHK 26.2 26.44 25.68 26.36 146092 20100218 CHK 27.12 27.56 26.85 27.46 232111 20100219 CHK 27.32 27.81 27.27 27.59 133841 20100222 CHK 27.75 27.79 26.945 27.1 137803 20100223 CHK 26.91 26.91 26.26 26.3 148778 20100224 CHK 26.48 26.69 26.25 26.54 105941 20100225 CHK 26.14 26.75 25.8401 26.73 137671 20100226 CHK 26.8 26.88 26.275 26.57 97169 20100301 CHK 26.73 26.84 26.47 26.68 91030 20100302 CHK 26.91 27.17 26.68 26.74 94158 20100303 CHK 26.87 27.01 26.67 26.8 76416 20100304 CHK 26.76 26.91 26.03 26.19 109936 20100305 CHK 26.38 26.5 26.1724 26.31 86833 20100308 CHK 26.16 26.35 25.48 25.59 161893 20100309 CHK 25.45 26.24 25.32 25.7 325373 20100310 CHK 25.9 25.95 25.38 25.66 124967 20100311 CHK 25.61 25.86 25.44 25.79 93378 20100312 CHK 25.92 25.98 25.46 25.64 109519 20100315 CHK 25.39 25.53 24.93 25.42 142453 20100316 CHK 25.44 25.55 25.18 25.42 112840 20100317 CHK 25.46 25.55 24.96 25.05 162725 20100318 CHK 24.81 24.92 23.75 23.79 289281 20100319 CHK 24.07 24.43 23.4 24.21 261577 20100322 CHK 23.75 23.75 23.18 23.24 367273 20100323 CHK 23.33 23.47 22.96 23.27 335134 20100324 CHK 23.06 23.68 23 23.11 282260 20100325 CHK 23.35 23.4 22.38 22.43 283462\n\n---\n\n22.74 66809 20100121 SE 22.77 23.06 22.4 22.61 71435 20100122 SE 22.48 22.5 21.94 21.99 70537 20100125 SE 22.1 22.45 22.1 22.29 43780 20100126 SE 22.1 22.52 22.1 22.26 41357 20100127 SE 22.26 22.37 21.69 22.04 46384 20100128 SE 22.17 22.5 21.62 21.81 39028 20100129 SE 21.9 22.05 21.2207 21.25 52884 20100201 SE 21.39 21.73 21.35 21.73 38897 20100202 SE 21.77 22.02 21.48 21.98 43712 20100203 SE 21.96 22.05 21.64 21.7 35403 20100204 SE 21.48 21.7 20.91 20.93 48844 20100205 SE 20.97 21.15 20.37 20.99 44617 20100208 SE 21.03 21.16 20.75 20.76 35074 20100209 SE 21.14 21.41 20.98 21.02 54013 20100210 SE 20.94 20.94 20.47 20.64 44973 20100211 SE 20.56 20.76 20.44 20.72 39186 20100212 SE 20.51 20.82 20.37 20.73 43161 20100216 SE 20.94 21.38 20.94 21.3 37072 20100217 SE 21.36 21.47 21.3 21.38 27535 20100218 SE 21.35 21.5 21.16 21.49 29982 20100219 SE 21.35 21.82 21.35 21.7 30634 20100222 SE 21.76 21.82 21.585 21.6 23527 20100223 SE 21.49 21.57 21.23 21.3 24950 20100224 SE 21.31 21.75 21.19 21.72 45130 20100225 SE 21.47 21.79 21.3 21.75 26961 20100226 SE 21.81 21.9 21.62 21.8 24838 20100301 SE 21.9 22.1067 21.86 21.98 32550 20100302 SE 22.02 22.12 21.88 21.98 33003 20100303 SE 21.99 22.11 21.82 21.88 27409 20100304 SE 21.84 22 21.61 21.72 30875 20100305 SE 21.83 22.13 21.78 22.1 31470 20100308 SE 22.1 22.24 22 22.07 19768 20100309 SE 21.86 22.09 21.83 22 23714 20100310 SE 22.02 22.38 21.94 22.32 40418 20100311 SE 22.32 22.37 22.15 22.32 20805 20100312 SE 22.45 22.49 22.15 22.31 18561 20100315 SE 22.39 22.44 22.01 22.32 23823 20100316 SE 22.41 22.475 22.2561 22.44 18240 20100317 SE 22.42 22.62 22.38 22.45 22397 20100318 SE 22.49 22.55 22.25 22.5 27080 20100319 SE 22.53 22.65 22.09 22.22 44475 20100322 SE 22.02 22.32 21.97 22.26 22251 20100323 SE 22.33 22.51 22.175 22.48 26028 20100324 SE 22.39 22.47 22.18 22.29 26304 20100325 SE 22.47 22.59 22.375 22.41 39305 20100326 SE 22.39 22.75 22.39 22.57 39928 20100329 SE 22.7 22.96 22.66 22.82 43033 20100330 SE 22.87 23 22.7 22.73 28671 20100331 SE 22.71 22.71 22.43 22.53 37773 20100401 SE 22.71 22.88 22.55 22.84 20138 20100405 SE 22.9 23.29 22.86 23.24 26490 20100406 SE 23.16 23.39 23.08 23.21 26269 20100407 SE 23.2 23.28 22.99 23.06 30596 20100408 SE 23 23.19 22.8 23.14 20718 20100409 SE 23.12 23.32 22.9 23.29 20115 20100412 SE 23.2 23.38 23.17 23.33 18928 20100413 SE 23.24 23.24 22.91 23.15 18753 20100414 SE 23.11 23.35 23.06 23.35 18149 20100415 SE 23.29 23.35 23.12 23.29 22041 20100416 SE 23.21 23.21 22.7 22.88 34635 20100419 SE 22.71 23.16 22.71 23.16 21517 20100420 SE 23.29 23.43 23.27 23.31 19066 20100421 SE 23.35 23.37 23.11 23.24 21997 20100422 SE 23.04 23.17 22.9 23.14 25886 20100423 SE 23.17 23.47 22.96 23.47 29973 20100426 SE 23.47 23.53 23.34 23.38 21036 20100427 SE 23.32 23.41 22.79 22.85 30564 20100428 SE 22.99 23.24 22.86 23.15 30976 20100429 SE 23.39 23.57 23.29 23.44 29892 20100430 SE 23.44 23.67 23.31 23.34 26721 20100503 SE 23.47 23.85 23.43 23.74 36547 20100504 SE 23.48 23.5 23.05 23.24 37284 20100505 SE 23.06 23.14 22.5 22.62 36347 20100506 SE 22.51 22.81 19.45 21.59 95495 20100507 SE 21.51 21.84 20.86 21.29 87098 20100510 SE 22.16 22.55 22.09 22.52 50314 20100511 SE 22.34 22.95 22.34 22.67 38619 20100512 SE 22.38 22.73 22.24 22.67 31153 20100513 SE 22.59 22.82 22.38 22.38 29009 20100514 SE 22.31 22.4 21.75 22.01 37608 20100517 SE 22.07 22.285 21.27 21.74 37951 20100518 SE 21.96 22.1 21.44 21.53 33324 20100519 SE 21.42 21.52 20.79 21.11 36517 20100520 SE 19.8 20.02 19.1 19.37 131282 20100521 SE 18.66 19.73 18.57 19.68 63299 20100524 SE 19.62 19.69 19.34 19.34 44882 20100525 SE 18.79 19.31 18.63 19.3 58107 20100526 SE 19.46 19.8 19.41 19.47 57298 20100527 SE 19.82 20.25 19.79 20.23 35546 20100528 SE 20.23 20.32 19.88 20.01 44095 20100601 SE 19.82 19.96 19.2 19.2 44092 20100602 SE 19.36 19.85 19.15 19.85 35495 20100603 SE 19.81 20.16 19.74 20.11 43587 20100604 SE 19.81 19.94 19.27 19.43 44531 20100607 SE 19.51 19.69 19.23 19.23 42711 20100608 SE 19.31 19.79 19.09 19.75 42038\n\n---\n\n32198 20091013 STI 22.32 22.48 21.87 22.01 71332 20091014 STI 22.63 22.7 22.25 22.46 85875 20091015 STI 22.24 22.64 22.12 22.25 86742 20091016 STI 21.77 21.91 21.34 21.71 72978 20091019 STI 21.78 21.92 20.76 21.08 95714 20091020 STI 20.92 21.05 20.065 20.82 90348 20091021 STI 20.74 21.65 20.59 20.76 107471 20091022 STI 21.28 22.44 20.05 21.85 166971 20091023 STI 21.86 21.86 20.4 20.99 142372 20091026 STI 20.22 20.64 19.525 19.85 194922 20091027 STI 19.89 20.13 19 19.19 126039 20091028 STI 19.22 19.63 18.45 18.89 178465 20091105 STI 19.58 20.29 19.3 20.27 101250 20091106 STI 19.91 20.42 19.705 19.93 59097 20091109 STI 20.29 21.01 19.94 21 72906 20091110 STI 20.9 20.95 20.08 20.29 68517 20091111 STI 20.5 21.19 20.35 21.07 71218 20091112 STI 20.94 21.05 20.16 20.25 78097 20091113 STI 20.32 20.675 19.92 20.07 59979 20091116 STI 20.44 21.02 20.3 20.91 92001 20091117 STI 20.84 21.95 20.79 21.86 132427 20091118 STI 21.87 22.45 21.58 21.94 141117 20091119 STI 21.43 21.99 21.43 21.86 79169 20091120 STI 21.67 22.07 21.57 22.04 72183 20091123 STI 22.26 23.35 22.26 23.15 113380 20091124 STI 23.02 23.43 22.71 22.84 98120 20091125 STI 23.04 23.1 22.64 22.7 46342 20091127 STI 22 22.82 21.93 22.59 54733 20091130 STI 22.63 23.7 22.6 23.63 83508 20091201 STI 23.71 23.87 23.11 23.2 96050 20091202 STI 23.9 24.09 22.89 23.29 169930 20091203 STI 23.07 23.29 22.3 22.35 139493 20091204 STI 22.84 23.03 22.41 22.8 102003 20091207 STI 22.77 23.02 22.46 22.62 55146 20091208 STI 22.3 22.835 22.22 22.5 42810 20091209 STI 22.78 22.78 22.14 22.2 45791 20091210 STI 22.25 22.39 21.84 21.92 40213 20091211 STI 22 22.32 21.81 22.31 37210 20091214 STI 22.39 22.4 21.77 22.28 38291 20091215 STI 22.06 22.17 20.8 21 121690 20091216 STI 21.21 21.42 20.7 20.85 76363 20091217 STI 20.65 21.2 20.5 20.58 79218 20091218 STI 20.44 21.04 20.04 21.01 112786 20091221 STI 21.01 21.25 20.78 21.23 45653 20091222 STI 21.13 21.18 20.755 20.85 54239 20091223 STI 20.8 20.93 20.25 20.28 49888 20091224 STI 20.43 20.84 20.43 20.74 20084 20091228 STI 20.63 20.91 20.45 20.55 38008 20091229 STI 20.66 20.77 20.43 20.56 26649 20091230 STI 20.4 20.5 20.07 20.18 34989 20091231 STI 20.21 20.47 20.13 20.29 37847 20100104 STI 20.65 20.69 20.21 20.44 66692 20100105 STI 20.34 20.78 20.16 20.72 82866 20100106 STI 20.62 21.47 20.33 21.3 82254 20100107 STI 21.4 23.29 21.04 22.56 155751 20100108 STI 22.43 23.04 22.32 23.01 67147 20100111 STI 23.11 23.35 22.72 23.27 71801 20100112 STI 23.03 23.1 22.38 22.45 92286 20100113 STI 22.61 22.9 22.11 22.78 82769 20100114 STI 22.78 23.99 22.66 23.7 79620 20100115 STI 23.49 23.6 22.95 23.39 103370 20100119 STI 23.28 23.47 23 23.35 58518 20100120 STI 23.19 23.93 23.11 23.42 82590 20100121 STI 23.53 25.89 23.51 24.53 181097 20100122 STI 24.53 25.67 23.66 24.55 208862 20100125 STI 24.54 24.7 23.06 24 123743 20100126 STI 23.79 24.38 23.46 23.62 99194 20100127 STI 23.57 24.81 23.44 24.7 111976 20100128 STI 26.01 26.2 24.57 24.81 205298 20100129 STI 24.59 24.77 24.2 24.33 134315 20100201 STI 24.46 24.58 23.64 24.5 114885 20100202 STI 24.5 24.68 23.98 24.27 117490 20100203 STI 24 24.05 22.86 23.27 138748 20100204 STI 23.22 23.3 21.92 22 124939 20100205 STI 21.96 22.67 21.44 22.49 91577 20100208 STI 22.37 23.09 21.84 22.4 76619 20100209 STI 22.61 23.07 22.4 22.69 57734 20100210 STI 22.59 23.41 22.49 22.99 58197 20100211 STI 22.94 23 22.38 22.48 91056 20100212 STI 22.26 22.4 21.8 22.37 83465 20100216 STI 22.71 22.89 22.53 22.69 90097 20100217 STI 22.91 23.02 22.41 22.6 90225 20100218 STI 22.44 22.78 22.08 22.62 94972 20100219 STI 22.65 23.12 22.65 23.03 79526 20100222 STI 23.16 23.9 23.05 23.65 70166 20100223 STI 23.71 23.74 22.69 22.76 77764 20100224 STI 22.85 23.87 22.77 23.77 86976 20100225 STI 23.39 23.55 22.93 23.52 68414 20100226 STI 23.59 23.86 23.19 23.81 68493 20100301 STI 23.79 23.86 23.3 23.64 43873 20100302 STI 23.67 24.72 23.67 24.43 76578 20100303 STI 24.51 24.64 24.08 24.16 39229 20100304 STI 24.17 24.44 24 24.38 42616 20100305 STI 24.45 25.09 24.35 25.06\n\n---\n\n23442 20100604 RTN 52.2 52.52 51.3 51.47 30766 20100607 RTN 51.58 51.68 50.7 50.72 32138 20100608 RTN 50.69 51.05 49.74 50.47 37189 20100609 RTN 50.64 51.34 50.35 50.51 32029 20100610 RTN 51.11 51.73 50.86 51.5 26956 20100611 RTN 51.06 51.76 50.66 51.71 17185 20100614 RTN 52.05 52.27 51.36 51.4 21390 20100615 RTN 51.84 53.13 51.84 53.13 24913 20100616 RTN 52.86 53.21 52.7 52.85 25650 20100617 RTN 53.1 53.16 52.39 53.1 18275 20100618 RTN 53.28 53.33 52.765 53.25 23985 20100621 RTN 53.58 53.76 52.92 53.19 20511 20100622 RTN 52.94 53.47 52.07 52.18 16499 20100623 RTN 52.12 52.42 51.41 51.96 23443 20100624 RTN 51.73 51.98 50.64 50.8 22660 20100625 RTN 50.82 51 50.05 50.38 59237 20100628 RTN 50.57 51.02 50.17 50.59 19923 20100629 RTN 49.89 50.05 48.42 48.75 27417 20100630 RTN 48.77 49.04 48.31 48.39 31560 20100701 RTN 47.93 48.01 47.19 47.73 29313 20100702 RTN 47.91 48.15 47.26 47.58 19862 20100706 RTN 47.99 48.18 47.02 47.47 21912 20100707 RTN 47.46 48.86 47.36 48.81 20025 20100708 RTN 49.03 49.59 48.85 49.5 19972 20100709 RTN 49.58 49.58 48.495 48.81 19399 20100712 RTN 48.52 48.71 47.965 48.1 17517 20100713 RTN 48.4 48.78 48.08 48.33 34453 20100714 RTN 48.22 48.86 47.91 48.57 25640 20100715 RTN 49.07 49.3 48.26 49.02 32270 20100716 RTN 48.83 49.315 47.68 47.73 26359 20100719 RTN 48.07 48.4 47.76 48.03 22098 20100720 RTN 47.51 48.56 47.09 48.45 24972 20100721 RTN 48.86 48.86 47.85 48.14 20129 20100722 RTN 48.58 48.99 48.2 48.69 32936 20100723 RTN 48.85 49.31 48.5 49.06 36466 20100726 RTN 49.27 50 49.26 49.64 30194 20100727 RTN 49.33 49.59 48.12 48.31 45260 20100728 RTN 48.26 48.6 48.17 48.27 34044 20100729 RTN 47.14 47.97 46.64 46.67 50950 20100730 RTN 46.31 46.61 46 46.27 43443 20100802 RTN 46.98 46.99 46.15 46.89 33912 20100803 RTN 46.67 46.88 45.9 45.99 44059 20100804 RTN 46.05 46.48 45.83 46.34 34109 20100805 RTN 46.17 46.85 45.95 46.43 33540 20100806 RTN 45.98 46.47 45.8 46.14 27316 20100809 RTN 46.43 46.75 46.32 46.45 22437 20100810 RTN 46.13 46.53 45.64 46.3 31702 20100811 RTN 45.74 45.83 44.74 44.93 27013 20100812 RTN 44.47 44.83 44.23 44.59 28128 20100813 RTN 44.49 45.185 44.49 44.74 21342 20100816 RTN 44.47 45.07 44.24 44.76 26755 20100817 RTN 45.15 45.8 44.95 45.46 29334 20100819 RTN 44.93 44.93 43.8901 44.01 35605 20100820 RTN 43.62 43.88 43.16 43.75 40716 20090821 RX 13.41 13.87 13.31 13.81 22659 20090824 RX 13.95 14 13.75 13.85 18686 20090825 RX 13.99 14.15 13.88 13.98 20810 20090826 RX 13.98 14.13 13.9 14.05 20942 20090827 RX 14.07 14.11 13.54 14.02 22628 20090828 RX 14.14 14.16 13.745 13.94 24822 20090831 RX 13.93 13.94 13.77 13.86 21181 20090901 RX 13.89 13.9 13.4125 13.45 19459 20090902 RX 13.53 13.63 13.23 13.52 20830 20090903 RX 13.49 13.89 13.37 13.87 24394 20090904 RX 13.9 14.01 13.76 13.93 16446 20090909 RX 14.07 14.36 14.06 14.27 11508 20090910 RX 14.33 14.42 14.15 14.4 10256 20090911 RX 14.44 14.74 14.34 14.72 26367 20090914 RX 14.91 14.91 14.68 14.85 18035 20090915 RX 14.89 14.89 14.66 14.85 13642 20090916 RX 14.97 15.25 14.85 15.21 18676 20090917 RX 15.29 15.54 15.25 15.33 19037 20090918 RX 15.41 15.52 15.27 15.46 15799 20090921 RX 15.45 15.65 15.35 15.54 15821 20090922 RX 15.61 15.61 15.31 15.44 12790 20090923 RX 15.5 15.51 15.22 15.25 14313 20090924 RX 15.27 15.36 15.02 15.09 22270 20090925 RX 15.13 15.23 15 15.06 27927 20090928 RX 15.15 15.56 15.1 15.41 16191 20090929 RX 15.46 15.81 15.35 15.54 20831 20090930 RX 15.515 15.57 15.11 15.35 18035 20091001 RX 15.33 15.42 14.86 14.95 17192 20091002 RX 14.85 14.922 14.61 14.67 18706 20091005 RX 14.75 14.87 14.61 14.83 14849 20091006 RX 14.96 14.964 14.76 14.83 13768 20091007 RX 14.82 14.84 14.61 14.81 14816 20091008 RX 14.92 15.3 14.87 15.23 13972 20091009 RX 15.24 15.27 15.025 15.12 13098 20091012 RX 15.2 15.26 15.11 15.23 10702 20091013 RX 15.17 15.32 15.01 15.17 15656 20091014 RX 15.28 15.29 15.02 15.16 14604 20091015 RX 15.15 15.29 15.04 15.24 12034 20091016 RX 15.11 15.26 14.65 14.67 42990 20091019 RX 14.72 17.89 14.51 17.84 88321 20091020 RX 17.48\n\n---\n\n170361 20100723 Q 5.62 5.64 5.58 5.64 159942 20100726 Q 5.63 5.66 5.62 5.66 344700 20100727 Q 5.65 5.67 5.63 5.64 250897 20100728 Q 5.63 5.66 5.6 5.62 207357 20100729 Q 5.64 5.645 5.59 5.62 219909 20100730 Q 5.6 5.66 5.58 5.66 178534 20100802 Q 5.66 5.68 5.64 5.66 568576 20100803 Q 5.64 5.67 5.6254 5.65 209741 20100804 Q 5.66 5.71 5.64 5.7 352208 20100805 Q 5.64 5.69 5.63 5.64 328263 20100806 Q 5.6 5.69 5.6 5.69 291089 20100809 Q 5.7 5.72 5.66 5.7 209312 20100810 Q 5.68 5.73 5.65 5.69 289505 20100811 Q 5.66 5.67 5.63 5.64 264830 20100812 Q 5.63 5.66 5.62 5.62 359504 20100813 Q 5.66 5.7 5.65 5.69 281409 20100816 Q 5.67 5.7 5.66 5.69 185230 20100817 Q 5.69 5.7 5.65 5.7 302070 20100819 Q 5.66 5.67 5.64 5.66 203526 20100820 Q 5.64 5.69 5.63 5.65 268576 20090821 QCOM 47.49 47.49 46.63 47.29 207027 20090824 QCOM 46.87 47.5 46.86 47.41 116223 20090825 QCOM 47.28 47.85 46.88 46.99 214903 20090826 QCOM 47 47.78 46.76 47.53 144803 20090827 QCOM 47.4 47.57 46.8 47.25 107199 20090828 QCOM 47.91 48.2 46.94 47.22 119810 20090831 QCOM 46.94 47 45.99 46.42 158731 20090901 QCOM 46.02 46.72 45.05 45.35 192796 20090902 QCOM 44.98 45.81 44.68 45.42 143835 20090903 QCOM 45.12 45.3 44.13 45.02 313554 20090904 QCOM 45.02 45.97 44.75 45.72 146853 20090909 QCOM 45.83 46.54 45.21 46.22 222530 20090910 QCOM 46.11 46.75 45.89 46.65 142697 20090911 QCOM 46.65 46.71 45.92 46.61 104663 20090914 QCOM 46.16 46.48 45.8 46.23 119864 20090915 QCOM 46.07 46.13 45.64 45.75 154200 20090916 QCOM 45.83 45.93 44.94 45.71 207648 20090917 QCOM 45.45 45.65 44.87 45.02 175424 20090918 QCOM 45.33 45.39 44 44.46 308740 20090921 QCOM 44.08 44.99 44.01 44.87 146164 20090922 QCOM 44.93 44.99 44.33 44.59 147343 20090923 QCOM 44.56 44.91 44.18 44.23 178773 20090924 QCOM 44.41 44.86 44.18 44.66 190089 20090925 QCOM 44.55 45.13 44.3 44.7 194911 20090928 QCOM 45.08 46.35 45.02 45.97 184971 20090929 QCOM 45.98 46.03 45.25 45.5 158082 20090930 QCOM 45.74 45.83 44.51 44.98 202639 20091001 QCOM 44.51 44.64 42.5 42.7 319587 20091002 QCOM 42.33 42.62 41.22 41.44 347135 20091005 QCOM 41.62 42.29 41.34 41.94 177903 20091006 QCOM 42.26 43.4 42.21 42.62 245798 20091007 QCOM 42.42 42.66 42.02 42.18 153306 20091008 QCOM 42.58 42.68 41.37 41.45 244278 20091009 QCOM 41.45 41.77 40.5 41.7 346014 20091012 QCOM 41.76 42.01 41.19 41.54 137321 20091013 QCOM 41.62 41.84 41.08 41.29 154472 20091014 QCOM 41.88 42.36 41.61 42.23 230377 20091015 QCOM 42.08 42.48 41.88 42.45 158838 20091016 QCOM 42.56 42.56 41.32 41.96 227462 20091019 QCOM 42.07 42.34 41.56 42.06 131269 20091020 QCOM 41.82 41.95 41.1 41.309 174238 20091021 QCOM 41.38 41.95 41.26 41.41 175781 20091022 QCOM 40.715 41.24 40.15 41.08 253526 20091023 QCOM 40.86 41.11 40.53 40.7 163685 20091026 QCOM 40.52 41.46 40.37 40.68 170759 20091027 QCOM 40.8 41.32 40.69 41 150875 20091028 QCOM 41.14 41.98 41 41.63 226018 20091105 QCOM 43.05 43.88 42.92 43.85 365388 20091106 QCOM 43.54 43.97 43.4 43.9 159936 20091109 QCOM 44.15 45 44.15 44.75 178268 20091110 QCOM 44.75 44.75 44.29 44.3517 125146 20091111 QCOM 44.37 44.75 44.35 44.66 156888 20091113 QCOM 45.28 46 45.24 45.77 164080 20091116 QCOM 45.85 46.25 45.29 45.51 133905 20091117 QCOM 45.52 45.99 45.46 45.99 103395 20091118 QCOM 45.84 45.93 45.2 45.49 131706 20091119 QCOM 45.11 45.36 44.55 45.09 149178 20091120 QCOM 44.83 45.25 44.76 45.1 125581 20091123 QCOM 45.25 45.9 45.25 45.55 94031 20091124 QCOM 45.86 46 45.38 45.56 111063 20091125 QCOM 45.74 45.84 45.34 45.44 83288 20091127 QCOM 44.74 45.39 44.69 44.99 61718 20091130 QCOM 44.76 45.07 44.32 45 113602 20091201 QCOM 45.05 45.47 44.88 45.06 141412 20091202 QCOM 45.21 45.55 44.9 45.06 125816 20091203 QCOM 45.13 45.28 44.6 44.63 107500 20091204 QCOM 45.02 45.68 44.68 45.16 146683 20091207 QCOM 45.14 45.42 44.8 44.89 84857 20091208 QCOM 44.74 45.2 44.13 44.59 131535 20091209 QCOM 44.35 44.87 44.18 44.77 114208 20091210 QCOM 45.01 45.79 44.95 45.56 148922 20091211 QCOM 45.79 45.88 44.73 44.9 164932 20091214 QCOM 45.14 45.22 44.58 44.67 117553 20091215\n\n---\n\n28.15 166099 20090921 HAL 27.33 27.87 27.19 27.45 95075 20090922 HAL 27.89 28.35 27.63 28.32 90518 20090923 HAL 28.46 28.58 27.33 27.35 110533 20090924 HAL 27.43 27.49 26.57 26.77 116792 20090925 HAL 26.42 26.98 26.19 26.74 112492 20090928 HAL 26.84 27.38 26.63 27.29 78201 20090929 HAL 27.16 27.55 26.89 27.31 90645 20090930 HAL 27.47 27.51 26.61 27.12 119581 20091001 HAL 27.12 27.25 26.34 26.4 169332 20091002 HAL 25.57 26.06 25.5 25.74 125385 20091005 HAL 25.67 26.65 25.64 26.48 98325 20091006 HAL 26.93 27.44 26.65 26.86 134913 20091007 HAL 26.85 28.08 26.835 28.02 167020 20091008 HAL 28.32 28.89 28.03 28.8 182929 20091009 HAL 28.64 28.79 28 28.22 109184 20091012 HAL 28.6 28.99 28.45 28.97 139014 20091013 HAL 29 29.08 28.1475 28.47 137176 20091014 HAL 28.99 29.26 28.72 29.19 122333 20091015 HAL 28.94 30 28.94 29.85 305477 20091016 HAL 30.13 31.27 29.94 30.4 311755 20091019 HAL 30.9 31.21 30.57 31.05 207968 20091020 HAL 31.25 31.65 30.23 30.8 178764 20091021 HAL 30.56 31.95 30.4 31 184802 20091022 HAL 30.86 31.6 30.38 31.41 115873 20091023 HAL 31.51 31.51 29.86 30.21 169383 20091026 HAL 30.3 31.05 29.47 29.7 147815 20091027 HAL 29.74 30.38 29.33 30.04 164222 20091028 HAL 29.73 29.9 28.78 28.94 220462 20091105 HAL 30.45 30.78 30.265 30.55 128545 20091106 HAL 30.2 31.58 30.2 31.03 159656 20091109 HAL 31.83 31.98 31.41 31.63 117598 20091110 HAL 31.44 31.88 30.825 31.47 101953 20091111 HAL 31.81 32 31.1 31.42 108609 20091112 HAL 31.22 31.32 30.12 30.3 159174 20091113 HAL 30.34 30.98 29.87 30.71 122454 20091116 HAL 30.92 32 30.81 31.72 143128 20091117 HAL 31.58 31.96 31.22 31.75 87904 20091118 HAL 31.95 31.95 31.19 31.69 103807 20091119 HAL 31.4 31.43 30.22 30.44 127241 20091120 HAL 30.22 30.46 29.72 29.88 154943 20091123 HAL 30.63 30.89 30.21 30.44 113442 20091124 HAL 30.26 30.775 29.96 30.46 98575 20091125 HAL 29.95 30.35 29.3 30.21 184083 20091127 HAL 28.99 29.43 28.28 29.09 88341 20091130 HAL 28.89 29.49 28.78 29.36 144287 20091201 HAL 29.63 29.87 29.26 29.35 139419 20091202 HAL 29.24 29.565 28.75 28.95 117806 20091203 HAL 28.75 28.86 27.98 28.06 144283 20091204 HAL 28.54 28.96 27.4 27.81 133015 20091207 HAL 27.57 28.24 27.5 27.7 90651 20091208 HAL 27.35 27.3999 26.7 26.8 180935 20091209 HAL 26.65 27.61 26.55 27.46 175548 20091210 HAL 27.58 28.4 27.58 28.17 149279 20091211 HAL 28 28.55 27.88 28.11 116694 20091214 HAL 28.58 28.95 28.5 28.64 97616 20091215 HAL 28.6 29.5 28.6 29.12 119779 20091216 HAL 29.35 30.13 29.29 29.6 115662 20091217 HAL 29.41 30.22 29.3 30.08 200575 20091218 HAL 30.38 30.39 29.48 29.62 168377 20091221 HAL 29.88 30.66 29.88 30.28 114239 20091222 HAL 30.21 30.5 30.1 30.16 82875 20091223 HAL 30.44 30.55 30.3 30.46 72363 20091224 HAL 30.5 30.64 30.19 30.27 33859 20091228 HAL 30.32 30.64 30.17 30.31 54015 20091229 HAL 30.4 30.53 29.54 29.64 93242 20091230 HAL 29.62 30.05 29.35 29.97 74711 20091231 HAL 30.31 30.52 29.99 30.09 76795 20100104 HAL 30.72 31.34 30.655 31.25 115715 20100105 HAL 31.21 31.83 30.99 31.65 189901 20100106 HAL 31.74 32.59 31.64 32.4 157207 20100107 HAL 32.31 32.52 31.92 32.48 90001 20100108 HAL 32.95 34.14 32.49 34.12 230147 20100111 HAL 34.71 34.87 33.38 33.78 159442 20100112 HAL 33.17 33.73 32.86 33.29 157395 20100113 HAL 33.35 34.21 33.17 34.05 138856 20100114 HAL 34.08 34.64 33.7 34.31 120079 20100115 HAL 34.19 34.29 33.47 34.03 119671 20100119 HAL 33.85 34.72 33.85 34.6 120180 20100120 HAL 34.1 34.24 33.01 33.27 174637 20100121 HAL 33.25 33.52 32.5 32.53 208255 20100122 HAL 32.27 32.47 31.05 31.15 215796 20100125 HAL 29.69 31.5 29.52 31.07 298149 20100126 HAL 30.83 31.495 30.31 30.88 189314 20100127 HAL 30.73 30.87 29.4 30.41 194106 20100128 HAL 30.83 30.83 29.36 29.65 168865 20100129 HAL 29.98 30.66 29.01 29.21 181972 20100201 HAL 29.57 30.7 29.53 30.65 138216 20100202 HAL 30.86 31.5 30.43 30.76 164140 20100203 HAL 30.71 31.21 30.155 30.36 110901 20100204 HAL 29.97 29.97 28.71 28.86 179608 20100205 HAL 28.81 29.26 27.71 28.29 220972 20100208 HAL 28.33 29.02 28.05 28.1 163367 20100209\n\n---\n\n20091222 NOVL 4.1 4.2 4.09 4.18 17176 20091223 NOVL 4.17 4.18 4.09 4.13 24114 20091224 NOVL 4.15 4.2 4.13 4.17 10902 20091228 NOVL 4.15 4.18 4.07 4.09 44998 20091229 NOVL 4.09 4.16 4.08 4.13 43146 20091230 NOVL 4.12 4.19 4.11 4.14 31424 20091231 NOVL 4.17 4.24 4.15 4.15 24024 20100104 NOVL 4.2 4.25 4.13 4.2 48152 20100105 NOVL 4.24 4.47 4.21 4.44 95492 20100106 NOVL 4.45 4.65 4.41 4.62 91401 20100107 NOVL 4.57 4.6 4.53 4.6 64070 20100108 NOVL 4.53 4.62 4.5 4.62 54857 20100111 NOVL 4.62 4.685 4.58 4.66 55207 20100112 NOVL 4.63 4.69 4.61 4.64 46377 20100113 NOVL 4.64 4.75 4.63 4.73 54307 20100114 NOVL 4.73 4.76 4.68 4.75 43913 20100115 NOVL 4.77 4.77 4.58 4.73 73207 20100119 NOVL 4.7 4.81 4.69 4.79 62936 20100120 NOVL 4.73 4.79 4.65 4.76 54985 20100121 NOVL 4.8 4.84 4.69 4.77 53582 20100122 NOVL 4.71 4.7895 4.62 4.64 48596 20100125 NOVL 4.7 4.7 4.65 4.66 31578 20100126 NOVL 4.65 4.71 4.63 4.68 33425 20100127 NOVL 4.65 4.68 4.6 4.66 27742 20100128 NOVL 4.66 4.65 4.52 4.58 43652 20100129 NOVL 4.61 4.65 4.47 4.47 60289 20100201 NOVL 4.61 4.62 4.43 4.57 58309 20100202 NOVL 4.57 4.92 4.55 4.87 91393 20100203 NOVL 4.85 4.85 4.74 4.82 53940 20100204 NOVL 4.74 4.8 4.66 4.68 48539 20100205 NOVL 4.67 4.76 4.64 4.72 40177 20100208 NOVL 4.73 4.88 4.6 4.74 50362 20100209 NOVL 4.78 4.9 4.71 4.84 43748 20100210 NOVL 4.82 4.84 4.73 4.79 36108 20100211 NOVL 4.79 4.82 4.7 4.76 38208 20100212 NOVL 4.7 4.87 4.69 4.75 45334 20100216 NOVL 4.81 4.89 4.76 4.86 26946 20100217 NOVL 4.88 4.9 4.81 4.85 34651 20100218 NOVL 4.88 4.97 4.85 4.96 28955 20100219 NOVL 4.94 5.05 4.9 4.93 41449 20100222 NOVL 4.92 4.97 4.87 4.92 43105 20100223 NOVL 4.88 4.93 4.83 4.84 21651 20100224 NOVL 4.85 4.89 4.82 4.86 24079 20100225 NOVL 4.78 4.81 4.69 4.81 46306 20100226 NOVL 4.73 4.76 4.66 4.7 77913 20100301 NOVL 4.71 4.82 4.65 4.8 52204 20100302 NOVL 4.8 4.86 4.73 4.75 115607 20100303 NOVL 6.07 6.15 5.93 6.08 1413344 20100304 NOVL 6.06 6.11 6.01 6.01 381655 20100305 NOVL 6.04 6.06 5.88 5.91 157709 20100308 NOVL 5.86 5.9898 5.76 5.81 144396 20100309 NOVL 5.95 6.02 5.81 5.85 159448 20100310 NOVL 5.87 5.89 5.78 5.81 72156 20100311 NOVL 5.81 5.89 5.77 5.8 106700 20100312 NOVL 5.82 5.85 5.69 5.72 148171 20100315 NOVL 5.72 5.84 5.7 5.8 53324 20100316 NOVL 5.78 5.81 5.73 5.78 69698 20100317 NOVL 5.77 5.815 5.72 5.77 87239 20100318 NOVL 5.77 5.79 5.7 5.72 54166 20100319 NOVL 5.73 5.77 5.6378 5.64 64741 20100322 NOVL 5.9 5.95 5.83 5.89 101742 20100323 NOVL 5.89 5.94 5.87 5.92 34819 20100324 NOVL 5.92 5.93 5.87 5.87 37531 20100325 NOVL 5.89 5.95 5.86 5.86 35542 20100326 NOVL 5.9 5.91 5.81 5.86 40500 20100329 NOVL 5.86 5.86 5.71 5.75 57594 20100330 NOVL 5.73 5.89 5.67 5.84 125821 20100331 NOVL 5.84 6.1 5.8 6 113256 20100401 NOVL 6.04 6.12 5.94 6.07 99255 20100405 NOVL 6.05 6.1 6 6.02 30362 20100406 NOVL 6.05 6.06 5.86 5.91 53695 20100407 NOVL 5.9 5.96 5.86 5.88 42697 20100408 NOVL 5.88 5.9 5.84 5.86 42299 20100409 NOVL 5.86 5.915 5.84 5.89 21702 20100412 NOVL 5.88 5.915 5.8 5.81 70082 20100413 NOVL 5.85 5.88 5.775 5.79 38044 20100414 NOVL 5.81 5.91 5.81 5.89 19017 20100415 NOVL 5.89 5.91 5.76 5.79 31558 20100416 NOVL 5.79 5.82 5.75 5.76 40613 20100419 NOVL 5.77 5.8 5.74 5.74 24229 20100420 NOVL 5.77 5.79 5.74 5.76 14604 20100421 NOVL 5.77 5.85 5.76 5.78 14085 20100422 NOVL 5.78 5.82 5.7592 5.78 22963 20100423 NOVL 5.8 5.82 5.75 5.78 26423 20100426 NOVL 5.79 5.87 5.76 5.84 26034 20100427 NOVL 5.81 5.88 5.75 5.75 29947 20100428 NOVL 5.75 5.79 5.7 5.71 42575 20100429 NOVL 5.73 5.76 5.69 5.74 20818 20100430 NOVL 5.76 5.76 5.61 5.6375 39188 20100503 NOVL 5.67 5.775 5.67 5.77 18675 20100504 NOVL 5.71 5.72 5.63 5.66 27348 20100505 NOVL 5.64 5.65 5.54 5.6 33272 20100506 NOVL 5.6 5.66 5.06 5.36 93956 20100507 NOVL 5.36 5.44 5.06 5.25 86771 20100510 NOVL 5.47 5.52 5.31 5.43 28336 20100511 NOVL 5.4 5.845 5.36 5.77 83804 20100512 NOVL 5.8 5.83 5.63 5.75 56592 20100513 NOVL 5.73 6.06 5.715 5.86 78830 20100514 NOVL 5.81 5.905 5.75 5.84 53196 20100517 NOVL 5.81 5.91 5.74 5.88 66451 20100518 NOVL 5.9\n\n---\n\n12690 20100312 AEE 25.82 25.89 25.5 25.51 11751 20100315 AEE 25.49 25.5999 25.35 25.49 16995 20100316 AEE 25.49 25.58 25.4 25.5 14483 20100317 AEE 25.5 25.7 25.43 25.67 10146 20100318 AEE 25.69 26 25.67 26 16273 20100319 AEE 26.03 26.2 25.83 26.04 29121 20100322 AEE 25.95 25.97 25.65 25.82 18658 20100323 AEE 25.79 25.9 25.73 25.88 9368 20100324 AEE 25.76 25.89 25.49 25.5 13366 20100325 AEE 25.57 25.68 25.28 25.29 17306 20100326 AEE 25.45 25.74 25.32 25.63 23685 20100329 AEE 25.74 25.99 25.61 25.93 15293 20100330 AEE 25.99 26.18 25.88 26.09 12188 20100331 AEE 26.11 26.14 25.86 26.08 18872 20100401 AEE 26.2 26.45 26.19 26.45 12585 20100405 AEE 26.55 26.55 26.35 26.48 17808 20100406 AEE 26.39 26.65 26.32 26.65 10517 20100407 AEE 26.64 26.72 26.4 26.46 13995 20100408 AEE 26.42 26.43 26.19 26.27 12066 20100409 AEE 26.26 26.51 26.18 26.51 9590 20100412 AEE 26.51 26.7799 26.51 26.73 9501 20100413 AEE 26.71 26.74 26.47 26.59 11040 20100414 AEE 26.56 26.66 26.41 26.65 12394 20100415 AEE 26.55 26.65 26.28 26.65 13903 20100416 AEE 26.61 26.75 26.31 26.35 17340 20100419 AEE 26.27 26.4 26.15 26.3 13753 20100420 AEE 26.45 26.7 26.37 26.7 12970 20100421 AEE 26.75 26.92 26.66 26.91 14180 20100422 AEE 26.9 26.9 26.45 26.64 19305 20100423 AEE 26.62 26.82 26.45 26.82 12651 20100426 AEE 26.86 26.86 26.63 26.68 9641 20100427 AEE 26.52 26.57 26.13 26.16 15155 20100428 AEE 26.23 26.56 26.02 26.47 16273 20100429 AEE 26.55 26.85 26.34 26.36 23147 20100430 AEE 26.04 26.29 25.11 25.96 41324 20100503 AEE 25.93 26.035 25.62 25.77 22902 20100504 AEE 25.63 25.67 25.35 25.64 25108 20100505 AEE 25.19 25.81 25.17 25.49 24213 20100506 AEE 25.45 25.48 23.09 24.66 42978 20100507 AEE 24.75 24.78 23.8 24.2 38021 20100510 AEE 24.96 25.21 24.69 25.2 23775 20100511 AEE 25.01 25.5 25.01 25.24 21023 20100512 AEE 25.19 25.54 25.05 25.5 16962 20100513 AEE 25.5 25.62 25.2 25.27 15532 20100514 AEE 25.15 25.3 24.82 25.09 18689 20100517 AEE 25.19 25.26 24.78 25.16 13636 20100518 AEE 25.31 25.65 24.98 25.03 16966 20100519 AEE 24.94 25.0396 24.42 24.7 17994 20100520 AEE 24.33 24.63 24 24.14 32185 20100521 AEE 23.88 24.19 23.75 24.14 36566 20100524 AEE 23.94 24.43 23.84 23.96 18531 20100525 AEE 23.52 23.78 23.14 23.74 31810 20100526 AEE 23.94 24.3 23.66 23.91 24438 20100527 AEE 24.3 24.48 24.15 24.41 14364 20100528 AEE 24.45 24.92 24.24 24.66 34528 20100601 AEE 24.47 24.51 23.95 23.97 23705 20100602 AEE 24.05 24.59 24.03 24.56 25685 20100603 AEE 24.6 24.93 24.56 24.86 19967 20100604 AEE 24.49 24.64 24.05 24.09 28395 20100607 AEE 23.68 24.145 23.66 23.89 25270 20100608 AEE 23.96 24.02 23.69 23.99 21296 20100609 AEE 24.11 24.17 23.73 23.8 17843 20100610 AEE 24.05 24.26 23.885 24.25 22849 20100611 AEE 24.08 24.22 23.84 24.12 16766 20100614 AEE 24.16 24.34 24.13 24.16 12194 20100615 AEE 24.33 24.89 24.33 24.87 19993 20100616 AEE 24.71 25.41 24.71 25.22 26142 20100617 AEE 25.3 25.56 25.08 25.56 15645 20100618 AEE 25.54 25.61 25.43 25.54 18660 20100621 AEE 25.71 25.77 25.24 25.32 12377 20100622 AEE 25.29 25.4 24.59 24.64 17510 20100623 AEE 24.68 24.71 24.19 24.32 12042 20100624 AEE 24.28 24.53 24.18 24.22 12468 20100625 AEE 24.19 24.4 24 24.26 16576 20100628 AEE 24.41 24.59 24.21 24.45 8590 20100629 AEE 24.25 24.26 23.8 23.93 21100 20100630 AEE 23.95 24.28 23.72 23.77 20832 20100701 AEE 23.82 23.83 23.45 23.59 19881 20100702 AEE 23.63 23.85 23.59 23.68 11207 20100706 AEE 23.84 24.22 23.725 23.96 15010 20100707 AEE 24.02 24.69 23.99 24.69 12926 20100708 AEE 24.83 24.88 24.56 24.8 18438 20100709 AEE 24.77 24.9 24.47 24.9 12768 20100712 AEE 24.86 25 24.71 24.93 7835 20100713 AEE 25.01 25.27 24.915 25.07 10674 20100714 AEE 24.96 25.09 24.8 25.04 16158 20100715 AEE 24.94 25.13 24.75 25.08 14947 20100716 AEE 24.96 25.07 24.57 24.6 15807 20100719 AEE 24.71 25.27 24.71 25.14 15978 20100720 AEE 24.96 25.03 24.62 25.02 25252 20100721 AEE 25.09 25.09 24.52 24.68 13443 20100722 AEE 24.9 25.23 24.88 25.07 14903 20100723 AEE 25.12 25.42 24.85 25.29 16726 20100726 AEE 25.33 25.67 25.3006 25.65 12300\n\n---\n\n18237 20091208 FHN 13.85 14.27 13.83 14.07 25784 20091209 FHN 13.97 14.2425 13.825 13.94 25698 20091210 FHN 14 14.01 13.71 13.85 23193 20091211 FHN 13.71 13.97 13.6 13.66 29110 20091214 FHN 13.71 14.25 13.62 13.9 37793 20091215 FHN 13.53 13.825 13.48 13.54 79448 20091216 FHN 13.65 13.66 13.32 13.49 39873 20091217 FHN 13.38 13.66 13.36 13.45 26156 20091218 FHN 13.41 13.46 13.3 13.45 34224 20091221 FHN 13.59 13.82 13.5 13.79 20483 20091222 FHN 13.81 13.9101 13.68 13.74 23458 20091223 FHN 13.79 13.83 13.55 13.56 12609 20091224 FHN 13.61 13.7 13.56 13.69 4640 20091228 FHN 13.62 13.78 13.4 13.47 9713 20091229 FHN 13.5 13.59 13.36 13.44 10419 20091230 FHN 13.36 13.54 13.35 13.5 14746 20091231 FHN 13.48 13.58 13.4 13.4 13677 20100104 FHN 13.48 13.57 13.32 13.4 25890 20100105 FHN 13.37 13.52 13.33 13.47 20624 20100106 FHN 13.46 14.04 13.43 13.85 40722 20100107 FHN 13.85 14.25 13.72 14.19 45616 20100108 FHN 14.1 14.2525 13.98 14.23 30999 20100111 FHN 14.34 14.34 13.94 14.11 16690 20100112 FHN 14.01 14.195 13.75 13.81 23358 20100113 FHN 13.69 14.19 13.58 13.94 30953 20100114 FHN 13.93 14.2312 13.89 14.1 27892 20100115 FHN 13.99 14.01 13.56 13.63 57310 20100119 FHN 13.45 14.09 13.08 13.35 115204 20100120 FHN 13.11 13.7 13.07 13.5 56833 20100121 FHN 13.46 14.01 13.46 13.59 64888 20100122 FHN 13.53 13.68 13.2 13.32 49546 20100125 FHN 13.39 13.54 13.08 13.22 30136 20100126 FHN 13.13 13.34 12.8 12.85 36996 20100127 FHN 12.88 13.28 12.83 13.24 40496 20100128 FHN 13.35 13.42 13.01 13.04 25062 20100129 FHN 13.12 13.16 12.85 12.95 37662 20100201 FHN 12.73 13.05 12.67 12.77 39004 20100202 FHN 12.73 12.85 12.54 12.75 33772 20100203 FHN 12.64 12.69 12.5 12.56 35223 20100204 FHN 12.51 12.72 12.19 12.44 51419 20100205 FHN 12.38 12.74 12.35 12.62 46126 20100208 FHN 12.63 12.86 12.4501 12.57 28246 20100209 FHN 12.69 12.91 12.64 12.82 30596 20100210 FHN 12.76 13.24 12.71 13.16 45619 20100211 FHN 13.16 13.2 12.78 12.88 34892 20100212 FHN 13.13 13.22 12.86 13.03 47995 20100216 FHN 13.1 13.19 12.96 13.06 29632 20100217 FHN 13.15 13.22 12.97 13.05 21245 20100218 FHN 13 13.08 12.93 12.96 18741 20100219 FHN 12.93 13 12.77 12.91 29879 20100222 FHN 12.97 13.14 12.91 13.06 28046 20100223 FHN 13.02 13.06 12.72 12.72 23083 20100224 FHN 12.72 12.93 12.71 12.81 37012 20100225 FHN 12.68 12.78 12.59 12.74 23376 20100226 FHN 12.76 12.88 12.67 12.8 22038 20100301 FHN 12.79 12.79 12.58 12.72 14689 20100302 FHN 12.72 13.05 12.72 12.79 19275 20100303 FHN 12.77 12.96 12.75 12.89 19603 20100304 FHN 12.89 13.26 12.83 13.23 26134 20100305 FHN 13.36 13.54 13.23 13.51 27884 20100308 FHN 13.49 13.74 13.45 13.56 19053 20100309 FHN 13.52 13.52 13.24 13.27 16431 20100310 FHN 13.24 13.34 13.12 13.26 37847 20100311 FHN 13.22 13.59 13.21 13.59 15442 20100312 FHN 13.68 13.7 13.33 13.39 13808 20100315 FHN 13.33 13.38 13.16 13.21 20748 20100316 FHN 13.21 13.44 13.14 13.43 15895 20100317 FHN 13.46 13.95 13.42 13.93 39025 20100318 FHN 13.91 14.31 13.83 14.26 60976 20100319 FHN 14.36 14.61 14.26 14.44 64876 20100322 FHN 13.9 14.31 13.8 14.14 42566 20100323 FHN 14.14 14.17 13.85 14.16 21926 20100324 FHN 14.14 14.24 14.04 14.12 13744 20100325 FHN 13.93 14.22 13.86 13.86 37423 20100326 FHN 14.26 14.39 14.01 14.05 90849 20100329 FHN 14.25 14.26 14 14.07 24677 20100330 FHN 14.09 14.14 13.95 13.97 16123 20100331 FHN 13.92 14.2 13.9 14.05 23628 20100401 FHN 14.13 14.27 14.05 14.27 14996 20100405 FHN 14.23 14.46 14.04 14.46 20737 20100406 FHN 14.4 14.7 14.16 14.66 43594 20100407 FHN 14.7 14.74 14.41 14.72 37383 20100408 FHN 14.75 15 14.6 14.87 27632 20100409 FHN 14.85 15.05 14.81 15.02 21569 20100412 FHN 15.13 15.36 14.955 15.03 42914 20100413 FHN 15.07 15.07 14.64 14.96 37628 20100414 FHN 15.13 15.57 14.99 15.55 37962 20100415 FHN 15.65 15.86 15.26 15.32 53376 20100416 FHN 14.72 14.72 13.85 14.02 158260 20100419 FHN 13.8 14.08 13.67 14.04 64605 20100420 FHN 14.16 14.36 13.93 14.28 47134 20100421 FHN 14.31 14.83 14.26 14.47 52504 20100422 FHN 14.35 14.735 14.25 14.7 26332 20100423 FHN 14.68 14.84\n\n---\n\n63029 20091201 IBM 127.29 128.39 126.85 127.94 65785 20091202 IBM 127.32 128.39 127.16 127.21 45996 20091203 IBM 127.6 128.47 127.25 127.55 57599 20091204 IBM 128.4 128.9 126 127.25 70689 20091207 IBM 126.88 127.53 126.59 127.04 41446 20091208 IBM 126.97 127.35 126.16 126.8 53514 20091209 IBM 126.7 128.39 126.11 128.39 60719 20091210 IBM 128.13 129.47 128.09 129.34 70779 20091211 IBM 129.01 129.77 128.71 129.68 65992 20091214 IBM 129.65 129.98 129.6 129.93 52021 20091215 IBM 129.46 129.86 127.94 128.49 80333 20091216 IBM 128.74 129.6 128.35 128.71 63727 20091217 IBM 128 128.56 127.12 127.4 59104 20091218 IBM 127.97 128.39 127 127.91 91066 20091221 IBM 127.8 128.94 127.68 128.65 47751 20091222 IBM 129.41 129.98 129.19 129.93 55356 20091223 IBM 129.7 130 129.3 130 41291 20091224 IBM 129.89 130.57 129.48 130.57 42650 20091228 IBM 130.99 132.31 130.72 132.31 58010 20091229 IBM 132.28 132.37 131.8 131.85 41847 20091230 IBM 131.23 132.68 130.68 132.57 38672 20091231 IBM 132.41 132.85 130.75 130.9 42251 20100104 IBM 131.18 132.97 130.85 132.45 61558 20100105 IBM 131.68 131.85 130.1 130.85 68424 20100106 IBM 130.68 131.49 129.81 130 56052 20100107 IBM 129.87 130.25 128.91 129.55 58405 20100108 IBM 129.07 130.9199 129.05 130.85 41971 20100111 IBM 131.06 131.06 128.67 129.48 57311 20100112 IBM 129.03 131.33 129 130.51 80833 20100113 IBM 130.39 131.12 129.16 130.23 64583 20100114 IBM 130.55 132.71 129.91 132.31 71145 20100115 IBM 132.03 132.89 131.089 131.78 85023 20100119 IBM 131.63 134.25 131.56 134.14 139161 20100120 IBM 130.46 131.15 128.95 130.25 152018 20100121 IBM 130.47 130.69 128.06 129 96086 20100122 IBM 128.67 128.89 125.37 125.5 100893 20100125 IBM 126.33 126.895 125.71 126.12 57389 20100126 IBM 125.92 127.75 125.41 125.75 71366 20100127 IBM 125.82 126.96 125.04 126.33 87194 20100128 IBM 127.03 127.04 123.05 123.75 96228 20100129 IBM 124.32 125 121.9 122.39 115723 20100201 IBM 123.23 124.95 122.78 124.67 72498 20100202 IBM 125.03 125.81 123.95 125.53 59001 20100203 IBM 125.16 126.07 125.07 125.66 41779 20100204 IBM 125.19 125.44 122.9 123 91299 20100205 IBM 123.04 123.72 121.83 123.52 86180 20100208 IBM 123.15 123.22 121.74 121.88 57193 20100209 IBM 122.65 124.2 122.46 123.21 60449 20100210 IBM 122.94 123.65 122.21 122.81 52192 20100211 IBM 122.58 124.2 122.06 123.73 50910 20100212 IBM 123.01 124.05 121.61 124 80182 20100216 IBM 124.91 125.23 124.11 125.23 67772 20100217 IBM 125.5 126.53 125.21 126.33 58273 20100218 IBM 126.13 128 126 127.81 55275 20100219 IBM 127.35 128.06 126.8724 127.19 63036 20100222 IBM 127.3 127.43 126.31 126.85 38080 20100223 IBM 126.48 127.66 126 126.46 45943 20100224 IBM 127.02 128.27 126.81 127.59 47821 20100225 IBM 126.06 127.24 125.57 127.07 56587 20100226 IBM 127.01 128 126.74 127.16 47841 20100301 IBM 127.5 128.83 127.47 128.57 45777 20100302 IBM 128.7 129.09 127.13 127.42 60134 20100303 IBM 127.73 128.02 126.68 126.88 63899 20100304 IBM 127.07 127.07 125.47 126.72 60323 20100305 IBM 127.17 127.55 127.04 127.25 61404 20100308 IBM 127.06 127.5 126.36 126.41 61995 20100309 IBM 126.27 126.29 125.2 125.55 75293 20100310 IBM 125.985 126.36 125.21 125.62 69175 20100311 IBM 125.71 127.81 125.71 127.6 79294 20100312 IBM 127.9 128.37 127.51 127.94 51700 20100315 IBM 127.4 128.34 127.28 127.83 45440 20100316 IBM 128 128.88 127.45 128.67 61350 20100317 IBM 128.9 128.93 127.36 127.76 63489 20100318 IBM 127.6 128.75 127.45 128.38 49546 20100319 IBM 128.84 128.93 126.78 127.71 107442 20100322 IBM 127.11 128.39 126.57 127.98 56518 20100323 IBM 127.94 129.43 127.64 129.37 59792 20100324 IBM 128.67 129.95 128.47 128.53 66692 20100325 IBM 129.41 130.73 129.13 129.24 76053 20100326 IBM 128.93 129.78 128.7205 129.26 55507 20100329 IBM 129.3 129.95 128.26 128.59 46432 20100330 IBM 128.9 129.13 128.25 128.77 34265 20100331 IBM 128.23 128.75 127.65 128.25 49047 20100401 IBM 128.95 129.31 127.55 128.25 49806 20100405 IBM 128.38 129.8 128.14 129.35 41188 20100406 IBM 128.68 129.3 128.05 128.93 39264 20100407 IBM 128.53\n\n---\n\n19.48 50710 20090918 WU 19.62 19.62 19.41 19.56 62050 20090921 WU 19.45 19.7 19.26 19.49 51522 20090922 WU 19.63 20.64 19.53 20.56 89045 20090923 WU 20.61 20.61 19.59 19.59 85569 20090924 WU 19.69 19.84 19.37 19.4 47623 20090925 WU 19.32 19.53 19 19.08 42077 20090928 WU 19.17 19.73 19.07 19.73 33756 20090929 WU 19.71 19.85 19.22 19.26 59241 20090930 WU 19.33 19.36 18.71 18.92 79065 20091001 WU 18.83 19.03 18.42 18.45 61213 20091002 WU 18.31 18.47 18.13 18.17 49927 20091005 WU 18.3 18.31 18.07 18.16 64763 20091006 WU 18.32 18.87 18.27 18.77 78295 20091007 WU 18.64 18.82 18.47 18.66 44028 20091008 WU 18.81 19.07 18.75 18.96 35376 20091009 WU 18.94 19.1 18.82 19.06 34513 20091012 WU 19.08 19.27 19.06 19.17 26412 20091013 WU 19.28 19.29 18.89 19.2 49609 20091014 WU 19.41 19.93 19.29 19.83 54463 20091015 WU 19.74 19.91 19.58 19.86 47946 20091016 WU 19.74 19.95 19.27 19.78 43661 20091019 WU 19.77 20.07 19.53 19.68 68647 20091020 WU 19.82 20.04 19.4 19.61 72381 20091021 WU 19.22 19.74 18.83 19.16 76348 20091022 WU 19.1 19.4 18.67 19.32 54314 20091023 WU 19.29 19.29 18.74 18.79 46569 20091026 WU 18.79 19.25 18.63 18.83 40931 20091027 WU 18.91 19.11 18.51 18.67 52711 20091028 WU 18.57 18.72 18.19 18.21 51885 20091105 WU 18.6 18.96 18.53 18.96 29864 20091106 WU 18.75 18.91 18.55 18.81 42169 20091109 WU 19 19.53 18.82 19.51 43245 20091110 WU 19.44 19.72 19.38 19.64 36813 20091111 WU 19.73 19.75 19.37 19.58 32600 20091112 WU 19.59 19.72 19.27 19.32 35378 20091113 WU 19.32 19.535 19.14 19.44 26443 20091116 WU 19.54 20.09 19.53 20.02 52549 20091117 WU 19.8 19.89 19.35 19.82 42768 20091118 WU 19.72 19.85 19.46 19.67 27452 20091119 WU 18.99 19.33 18.94 19.28 54375 20091120 WU 19.21 19.25 18.71 18.83 93199 20091123 WU 18.95 19.21 18.91 18.98 53069 20091124 WU 19.05 19.1 18.9 18.92 47627 20091125 WU 18.91 18.99 18.86 18.91 50013 20091127 WU 18.42 18.73 18.3 18.5 26642 20091130 WU 18.55 18.72 18.32 18.45 59024 20091201 WU 18.58 18.72 18.45 18.49 82648 20091202 WU 18.47 18.76 18.28 18.4 68836 20091203 WU 18.42 18.55 17.81 17.84 81113 20091204 WU 18.07 18.34 17.99 18.14 67333 20091207 WU 18.22 18.42 18 18.24 44338 20091208 WU 18.15 18.33 17.97 18.05 42969 20091209 WU 18.15 18.28 18.03 18.19 36161 20091210 WU 18.4 19.08 18.4 19 88125 20091211 WU 19.11 19.24 18.93 19.07 51320 20091214 WU 19.26 19.36 19 19.21 33219 20091215 WU 19.16 19.16 18.9 18.97 49240 20091216 WU 19.11 19.32 19.06 19.23 47648 20091217 WU 19.06 19.25 19 19.03 45088 20091218 WU 19.24 19.36 18.91 19.13 59878 20091221 WU 19.25 19.43 19.14 19.24 44430 20091222 WU 19.22 19.47 19.19 19.39 35389 20091223 WU 19.37 19.56 19.35 19.44 24827 20091224 WU 19.51 19.51 19.19 19.25 15199 20091228 WU 19.28 19.31 19.03 19.1 28251 20091229 WU 19.22 19.35 18.99 19.07 31340 20091230 WU 19 19.125 18.905 19.02 28735 20091231 WU 19.02 19.14 18.82 18.85 24181 20100104 WU 19.1 19.24 19.045 19.09 42778 20100105 WU 19.15 19.15 18.77 19.01 39148 20100106 WU 18.89 19.05 18.87 19 42078 20100107 WU 18.92 19.73 18.85 19.61 82568 20100108 WU 19.6 19.81 19.46 19.8 56738 20100111 WU 19.96 19.99 19.74 19.97 53261 20100112 WU 19.87 19.91 19.41 19.85 50871 20100113 WU 19.92 20.26 19.89 20.13 57821 20100114 WU 20.08 20.08 19.74 19.88 32485 20100115 WU 19.94 19.94 19.49 19.53 47125 20100119 WU 19.5 19.86 19.4 19.86 55099 20100120 WU 19.71 19.71 19.35 19.5 50089 20100121 WU 19.57 19.75 19.31 19.43 66011 20100122 WU 19.4 19.47 18.66 18.8 81536 20100125 WU 19.11 19.11 18.5 18.63 46017 20100126 WU 18.46 18.625 18.24 18.31 63897 20100127 WU 18.25 18.45 18.19 18.35 59301 20100128 WU 18.46 18.51 18.15 18.25 56981 20100129 WU 18.44 18.84 18.32 18.54 67242 20100201 WU 18.66 18.7 18.395 18.58 61743 20100202 WU 18.59 18.88 18.52 18.85 56098 20100203 WU 17.07 18.21 16.7 17.17 508481 20100204 WU 16.8 16.89 16.22 16.54 342944 20100205 WU 16.43 16.54 15.85 16.5 167198 20100208 WU 16.53 16.55 16.14 16.16 147857 20100209 WU 16.35 16.51 15.93 16.14 194611 20100210 WU 16.14 16.6 16.01 16.44 157284 20100211 WU 16.3 16.41 16.1 16.16 157815\n\n---\n\n27.31 27.54 57561 20100628 FIS 27.51 27.75 27.26 27.4 18080 20100629 FIS 27.18 27.29 26.91 27.05 45236 20100630 FIS 27.01 27.35 26.78 26.82 34760 20100701 FIS 27.01 27.05 26.45 26.53 59679 20100702 FIS 26.51 26.77 26.35 26.41 25303 20100706 FIS 27.49 27.49 26.62 27.17 70148 20100707 FIS 27.07 27.6 27.07 27.55 58059 20100708 FIS 27.66 27.77 27.49 27.65 43722 20100709 FIS 27.71 27.755 27.59 27.7 37557 20100712 FIS 27.7 27.87 27.54 27.75 66646 20100713 FIS 27.87 27.94 27.66 27.77 77042 20100714 FIS 27.74 28.15 27.7 27.93 72281 20100715 FIS 27.83 28.06 27.72 27.97 38056 20100716 FIS 27.81 27.88 27.5 27.52 60314 20100719 FIS 27.62 27.73 27.45 27.63 32132 20100720 FIS 27.55 27.97 27.44 27.9 74450 20100721 FIS 28 28 27.64 27.71 54270 20100722 FIS 27.84 28.15 27.8 28.03 69859 20100723 FIS 28.05 28.24 27.79 28.1 45549 20100726 FIS 28.11 28.27 27.87 28.2 51373 20100727 FIS 28.24 28.51 28.16 28.36 76270 20100728 FIS 28.34 28.62 28.32 28.5 98298 20100729 FIS 28.54 28.775 28.475 28.65 97660 20100730 FIS 28.44 28.73 28.44 28.67 88637 20100802 FIS 28.85 28.91 28.71 28.72 186941 20100803 FIS 28.73 29 28.7 28.79 220803 20100804 FIS 28 28 27.26 27.5 303905 20100805 FIS 27.46 27.82 27.27 27.66 76403 20100806 FIS 27.61 27.74 27.47 27.7 62512 20100809 FIS 27.81 28.01 27.57 27.88 49211 20100810 FIS 27.69 27.84 27.1 27.1 91137 20100811 FIS 26.75 26.81 26.36 26.36 68435 20100812 FIS 26.06 26.535 25.81 26.37 90382 20100813 FIS 26.35 26.6 26.23 26.5 115726 20100816 FIS 26.39 26.64 26.25 26.34 111754 20100817 FIS 26.51 26.96 26.44 26.84 48766 20100819 FIS 26.81 26.81 26.25 26.43 30515 20100820 FIS 26.36 26.56 26.28 26.49 21570 20090821 FISV 48.33 49.17 47.17 49.09 12086 20090824 FISV 49.19 49.46 48.97 49.3 11608 20090825 FISV 49.67 49.75 49.199 49.5 14434 20090826 FISV 49.33 49.89 49.29 49.46 10072 20090827 FISV 49.58 49.69 48.62 49.62 7889 20090828 FISV 49.81 49.91 48.76 49.21 6745 20090831 FISV 48.96 49.23 48.08 48.25 12430 20090901 FISV 48.24 49.21 47.53 47.55 18694 20090902 FISV 47.29 47.54 47.09 47.28 15792 20090903 FISV 47.27 47.37 46.4 46.88 17755 20090904 FISV 46.98 48.04 46.74 47.82 12283 20090909 FISV 47.79 48.67 47.475 48.61 21670 20090910 FISV 48.26 48.52 47.97 48.52 8776 20090911 FISV 48.19 48.52 47.98 48 11252 20090914 FISV 47.72 48.21 47.47 48.16 13676 20090915 FISV 48.13 48.83 47.89 48.69 11251 20090916 FISV 48.66 49.36 48.13 49.2 13268 20090917 FISV 49.23 49.72 49.07 49.39 9338 20090918 FISV 49.68 49.8 49.17 49.43 15687 20090921 FISV 49.38 49.87 49.01 49.65 10533 20090922 FISV 49.68 49.84 49.04 49.32 9436 20090923 FISV 49.07 49.71 48.99 49.06 18112 20090924 FISV 49.16 49.28 48.3 48.43 14257 20090925 FISV 48.63 49.2 48.21 48.46 15047 20090928 FISV 48.48 49.21 48.4 49 14161 20090929 FISV 48.68 49.16 47.92 47.96 15025 20090930 FISV 48.1 48.57 47.1 48.2 22132 20091001 FISV 47.82 48.12 46.71 47.02 24970 20091002 FISV 46.84 47.31 46.66 46.84 11835 20091005 FISV 46.8 47.4698 46.66 47.39 10702 20091006 FISV 46.95 48.11 46.9 47.93 10180 20091007 FISV 47.53 48.34 47.49 48.23 12843 20091008 FISV 48.57 48.98 48.32 48.48 11100 20091009 FISV 48.23 49.05 48.07 49.04 10327 20091012 FISV 48.58 49.25 48.52 48.87 7168 20091013 FISV 48.73 48.74 48.27 48.61 10431 20091014 FISV 48.71 49.13 48.62 49.1 9807 20091015 FISV 48.92 49.28 48.74 49.11 7466 20091016 FISV 48.82 49.2701 47.93 48.35 18715 20091019 FISV 48.45 49.46 48.36 49.43 18510 20091020 FISV 49.31 49.39 48.79 49.18 13258 20091021 FISV 49.26 50 49.09 49.3 15282 20091022 FISV 49.35 49.59 48.49 49.4 12851 20091023 FISV 48.8 49.68 48.55 48.61 10554 20091026 FISV 48.79 49.65 48.21 48.79 16139 20091027 FISV 49.38 49.56 48.66 49.08 15942 20091028 FISV 48.03 48.2 46 46.14 33535 20091105 FISV 46.69 47.78 46.51 47.7 12147 20091106 FISV 47.16 47.78 47.06 47.58 8716 20091109 FISV 47.72 48.64 47.61 48.64 10179 20091110 FISV 48.34 48.7 48.18 48.48 8856 20091111 FISV 48.38 48.88 48.09 48.51 7604 20091113 FISV 47.93 48.01 47.24 47.83 19545 20091116 FISV 47.74 48.69 47.72 48.56 8609 20091117 FISV 48.45 48.84 48.19\n\n---\n\n9785 20100621 AYE 22.46 22.49 21.7392 21.94 23755 20100622 AYE 21.98 21.98 21.15 21.2 21496 20100623 AYE 21.26 21.39 20.93 21.04 8429 20100624 AYE 20.98 21.44 20.86 21.05 15512 20100625 AYE 21.05 21.26 20.77 21.03 39006 20100628 AYE 21.04 21.4325 20.92 21.29 13473 20100629 AYE 21.07 21.13 20.73 20.79 27205 20100630 AYE 20.72 21.13 20.59 20.68 18408 20100701 AYE 20.69 20.69 20.2 20.32 19731 20100702 AYE 20.34 20.46 20.01 20.14 18212 20100706 AYE 20.46 20.64 20.23 20.49 21104 20100707 AYE 20.5 21.34 20.38 21.32 21829 20100708 AYE 21.44 21.7 21.3 21.7 15626 20100709 AYE 21.69 22.11 21.53 22.07 12394 20100712 AYE 21.97 22.2 21.82 22.16 7776 20100713 AYE 22.32 22.59 22.1 22.23 16154 20100714 AYE 22.21 22.5 22 22.48 11512 20100715 AYE 22.42 22.535 22.19 22.43 15964 20100716 AYE 22.27 22.43 22.14 22.3 18372 20100719 AYE 22.37 22.83 22.21 22.76 15312 20100720 AYE 22.56 23.06 22.47 23.06 14858 20100721 AYE 23.13 23.26 22.78 22.9 16335 20100722 AYE 23.02 23.5 23.02 23.34 14372 20100723 AYE 23.35 23.3799 22.84 23.08 18774 20100726 AYE 23.03 23.25 22.93 23.08 14091 20100727 AYE 23.26 23.74 23.1 23.72 29506 20100728 AYE 23.6 23.815 23.4993 23.61 31366 20100729 AYE 23.63 23.74 22.84 23.09 34744 20100730 AYE 22.84 22.96 22.61 22.8 28697 20100802 AYE 23.06 23.33 22.96 23.31 20201 20100803 AYE 23.24 23.71 23.22 23.48 37032 20100804 AYE 23.39 23.45 22.93 23.37 17702 20100805 AYE 23.05 23.415 22.96 23.25 19908 20100806 AYE 23.12 23.25 22.82 23.07 30395 20100809 AYE 23.15 23.24 22.92 23.06 20333 20100810 AYE 22.95 23.19 22.67 23.02 43530 20100811 AYE 22.76 22.76 22.21 22.3 26695 20100812 AYE 22 22.2 21.95 22.07 17857 20100813 AYE 21.95 22.5 21.95 22.27 14293 20100816 AYE 22.24 22.49 22.04 22.49 17505 20100817 AYE 22.58 23 22.49 22.81 16627 20100819 AYE 22.65 22.65 22.19 22.29 19338 20100820 AYE 22.19 22.26 21.98 22.04 15804 20090821 AZO 151.8 153.28 151.03 153.25 5204 20090824 AZO 152.96 153.37 150.66 150.8 5927 20090825 AZO 151.27 151.81 149.69 149.98 8689 20090826 AZO 149.76 151.95 149.42 150.22 6983 20090827 AZO 149.7 150.23 147.81 149.07 8632 20090828 AZO 149.6 150.57 147 148.45 11217 20090831 AZO 146.61 147.56 145.76 147.25 11537 20090901 AZO 146.34 147.95 144.24 144.94 10060 20090902 AZO 145.14 146.17 144.2 145.25 5781 20090903 AZO 145.38 148.98 144.77 148.81 8172 20090904 AZO 148.95 148.99 147.25 148.18 4621 20090909 AZO 149.84 150.3 148.04 149.32 6081 20090910 AZO 149.31 150.23 147.88 149.4 5725 20090911 AZO 148.75 149.16 145.87 146.45 9961 20090914 AZO 145.34 147.44 144.82 147.2 5787 20090915 AZO 147.36 147.76 145.36 147.28 8256 20090916 AZO 147.59 148.76 146.42 147.41 6221 20090917 AZO 147.56 148.97 146.73 147.37 6167 20090918 AZO 146.91 152.55 146.88 152.09 15510 20090921 AZO 151.81 154.31 150 153.55 9015 20090922 AZO 154.69 154.69 151.74 152.92 8698 20090923 AZO 148.61 148.94 141.44 141.5 39022 20090924 AZO 142.72 144.4 142.05 142.5 16205 20090925 AZO 142.18 144.501 142 143.97 11592 20090928 AZO 143.98 145.44 142.41 142.77 8626 20090929 AZO 143.26 146.76 143.26 145.98 15280 20090930 AZO 145.17 147 144.45 146.22 9944 20091001 AZO 145.77 147.06 144.13 145.62 13803 20091002 AZO 144.21 147.32 143.82 146.05 11320 20091005 AZO 145.7 147.12 144.57 145.14 11861 20091006 AZO 146.24 147.66 145.33 147.08 9279 20091007 AZO 146.59 147.4 144.7 147.21 7777 20091008 AZO 147.5 148.78 146.86 147.12 6061 20091009 AZO 147.11 147.74 145.05 145.92 7460 20091012 AZO 146.12 146.83 144.4 144.87 7464 20091013 AZO 144.82 145.92 143.86 144.7 6634 20091014 AZO 145 145.89 143.4 143.95 11636 20091015 AZO 143.41 145.36 143.21 144.67 9082 20091016 AZO 143.81 145.91 143.81 144.52 7396 20091019 AZO 143.84 145.34 142.25 144 13629 20091020 AZO 143.9 143.9 140.4 140.94 13778 20091021 AZO 141.07 142 137.98 137.99 11664 20091022 AZO 137.47 139.45 137.19 139.1 9294 20091023 AZO 139.59 139.59 137.28 137.62 8408 20091026 AZO 137.51 139.15 137.03 137.46 5570 20091027 AZO 137.46 138.79 135.68 137.17 9155 20091028 AZO 136.55 138.97 136.34 136.42 10667 20091105 AZO 140.16 140.835\n\n---\n\nSE 18.79 18.88 18.59 18.82 34654 20090901 SE 18.76 18.8605 18.33 18.36 35843 20090902 SE 18.32 18.42 18.2 18.28 22223 20090903 SE 18.46 18.47 18.05 18.23 31103 20090904 SE 18.23 18.47 18.16 18.39 26806 20090909 SE 18.77 19.06 18.69 18.82 36369 20090910 SE 18.9 19.16 18.73 19.08 27488 20090911 SE 19.16 19.28 19.03 19.09 27901 20090914 SE 19.18 19.26 18.89 19.18 31569 20090915 SE 19.18 19.45 19 19.44 39335 20090916 SE 19.41 19.72 19.35 19.71 35461 20090917 SE 19.65 19.73 19.36 19.39 39269 20090918 SE 19.53 19.59 19.3 19.5 44586 20090921 SE 19.17 19.5 19.16 19.43 24701 20090922 SE 19.72 19.72 19.42 19.67 30795 20090923 SE 19.67 19.71 19.29 19.29 31433 20090924 SE 19.32 19.42 18.96 19.05 34045 20090925 SE 18.96 19.31 18.89 19.07 31664 20090928 SE 19.13 19.34 19.03 19.19 24264 20090929 SE 19.21 19.28 19.04 19.14 25823 20090930 SE 19.24 19.26 18.75 18.94 52220 20091001 SE 18.93 19.02 18.58 18.61 45098 20091002 SE 18.36 18.57 18.26 18.42 43315 20091005 SE 18.47 18.92 18.36 18.9 32573 20091006 SE 19.09 19.18 18.95 19.15 43570 20091007 SE 19.15 19.28 18.95 19.21 25657 20091008 SE 19.31 19.65 19.16 19.5 36007 20091009 SE 20.41 20.45 19.74 19.76 58089 20091012 SE 20 20.14 19.82 19.93 28894 20091013 SE 20.01 20.03 19.65 19.76 30201 20091014 SE 19.98 20.1 19.82 20.1 35321 20091015 SE 19.97 20.53 19.91 20.53 37705 20091016 SE 20.35 20.39 20.05 20.33 37418 20091019 SE 20.28 20.46 20.16 20.42 26675 20091020 SE 20.55 20.55 20.075 20.3 33626 20091021 SE 20.21 20.42 20.03 20.2 46745 20091022 SE 20.18 20.4 20.05 20.35 36187 20091023 SE 20.36 20.48 19.85 20 43450 20091026 SE 20 20.45 19.69 19.69 43123 20091027 SE 19.21 19.58 18.6 19.49 69625 20091028 SE 19.41 19.41 18.98 19 47917 20091105 SE 19.71 19.74 19.15 19.34 46425 20091106 SE 19.13 19.41 19.09 19.34 25403 20091109 SE 19.57 19.7 19.34 19.69 39275 20091110 SE 19.43 19.48 19.21 19.34 36419 20091111 SE 19.44 19.55 19.15 19.25 29241 20091112 SE 19.17 19.33 18.93 18.97 32117 20091113 SE 18.99 19.25 18.91 19.17 30965 20091116 SE 19.2 19.5 19.02 19.38 32231 20091117 SE 19.37 19.45 19.14 19.37 27989 20091118 SE 19.4 19.45 19.14 19.25 18795 20091119 SE 19.2 19.2 18.83 19.01 33444 20091120 SE 19.06 19.18 18.9 19.1 28241 20091123 SE 19.32 19.67 19.32 19.39 36473 20091124 SE 19.36 19.44 19.15 19.43 24613 20091125 SE 19.51 19.67 19.42 19.66 17920 20091127 SE 19.24 19.43 19.1 19.31 17792 20091130 SE 19.38 19.55 19.19 19.41 25361 20091201 SE 19.41 19.63 19.41 19.57 24388 20091202 SE 19.62 19.68 19.4301 19.51 25748 20091203 SE 19.54 19.74 19.41 19.42 26423 20091204 SE 19.71 19.88 19.48 19.62 38138 20091207 SE 19.62 19.82 19.59 19.62 23294 20091208 SE 19.5 19.6799 19.34 19.54 25785 20091209 SE 19.56 19.73 19.5 19.68 29761 20091210 SE 19.72 20.15 19.72 20.11 29976 20091211 SE 20.21 20.25 20.02 20.19 21132 20091214 SE 20.43 20.73 20.4 20.57 28916 20091215 SE 20.64 20.665 20.38 20.4 41804 20091216 SE 20.58 20.72 20.28 20.51 29449 20091217 SE 20.39 20.52 20.305 20.35 20576 20091218 SE 20.4 20.57 20.19 20.23 43385 20091221 SE 20.25 20.53 20.25 20.42 22582 20091222 SE 20.5 20.53 20.29 20.44 20042 20091223 SE 20.41 20.54 20.41 20.51 15842 20091224 SE 20.47 20.67 20.47 20.58 9047 20091228 SE 20.58 20.66 20.44 20.54 13850 20091229 SE 20.56 20.69 20.51 20.56 16590 20091230 SE 20.47 20.78 20.47 20.65 19417 20091231 SE 20.63 20.75 20.51 20.51 12932 20100104 SE 20.66 20.81 20.61 20.81 31012 20100105 SE 20.85 20.89 20.3 20.66 46405 20100106 SE 20.6 20.81 20.6 20.7 36176 20100107 SE 20.64 20.81 20.53 20.81 29716 20100108 SE 20.87 21 20.75 20.99 28269 20100111 SE 21.08 21.23 20.98 21.06 39123 20100112 SE 20.96 21.39 20.85 21.13 52826 20100113 SE 21.49 21.76 21.42 21.7 52865 20100114 SE 22 22.28 21.79 22.18 46966 20100115 SE 22.37 22.37 21.85 22.12 48229 20100119 SE 22.19 23.06 22.16 23.03 59719 20100120 SE 22.85 22.94 22.675 22.74 66809 20100121 SE 22.77 23.06 22.4 22.61 71435 20100122 SE 22.48 22.5 21.94 21.99 70537 20100125 SE 22.1 22.45 22.1 22.29 43780 20100126 SE 22.1 22.52 22.1 22.26 41357 20100127 SE 22.26 22.37\n\n---\n\na,b,c\n1,2,qq\n1,2,qq\n1,2,qq\n1,2,qq\n4,5\n\n1,2,qq\n1,2,qq\n1,2,qq\n1,2,qq\n1,2,qq\n1\n\n\n1,2,qq\n\n1,2,qq\n1,2,qq\n1,2,qq\n1\n\n1\n1\n1,2,qq\n1,2,qq\n1,2,qq\n1,2,er\n\n---\n\n21.19 20.82 21.02 23162 20100211 AYE 22.78 23.77 22.78 23.55 281235 20100212 AYE 23.49 23.56 22.54 22.72 135049 20100216 AYE 23.05 23.22 22.6 22.84 54802 20100217 AYE 22.87 22.9965 22.49 22.59 36250 20100218 AYE 22.63 22.77 22.48 22.7 28832 20100219 AYE 22.61 23.445 22.53 23.35 26612 20100222 AYE 23.37 23.59 23.26 23.37 41076 20100223 AYE 23.34 23.36 22.945 23 28138 20100224 AYE 23.04 23.05 22.775 23.01 22778 20100225 AYE 22.61 23 22.55 22.95 34089 20100226 AYE 22.93 22.99 22.6 22.65 32401 20100301 AYE 22.74 23.07 22.74 22.94 23944 20100302 AYE 23.03 23.2 22.99 23.08 24313 20100303 AYE 23.15 23.16 22.89 22.97 34270 20100304 AYE 22.9 22.97 22.67 22.75 28709 20100305 AYE 22.83 23.29 22.82 23.23 25602 20100308 AYE 23.25 23.32 23.16 23.25 12995 20100309 AYE 23.18 23.3099 23.08 23.19 15198 20100310 AYE 23.13 23.49 23.13 23.37 22777 20100311 AYE 23.39 23.48 23.3099 23.41 14596 20100312 AYE 23.41 23.535 23.2 23.28 16774 20100315 AYE 23.23 23.44 23.2 23.38 27064 20100316 AYE 23.48 23.59 23.29 23.58 14947 20100317 AYE 23.6 23.745 23.5 23.67 19509 20100318 AYE 23.61 23.7 23.26 23.36 12006 20100319 AYE 23.46 23.6 23.242 23.44 13632 20100322 AYE 23.3 23.65 23.26 23.49 20697 20100323 AYE 23.49 23.99 23.49 23.78 21963 20100324 AYE 23.83 23.9 23.69 23.76 27376 20100325 AYE 23.75 23.88 23.05 23.1 24425 20100326 AYE 23.07 23.22 22.82 22.89 26987 20100329 AYE 22.91 23 22.66 22.92 29211 20100330 AYE 22.89 23 22.81 22.89 24598 20100331 AYE 22.83 23.09 22.74 23 32733 20100401 AYE 23.09 23.24 23 23.05 31372 20100405 AYE 23.07 23.1525 23 23.07 26255 20100406 AYE 22.99 23.22 22.97 23.22 36985 20100407 AYE 23.09 23.25 22.9975 23.09 21981 20100408 AYE 23.04 23.12 22.97 23.02 16414 20100409 AYE 23 23.25 22.97 23.25 21664 20100412 AYE 23.31 23.47 23.2 23.23 20422 20100413 AYE 23.25 23.35 22.98 23.08 29771 20100414 AYE 23.05 23.14 22.8 22.83 35114 20100415 AYE 22.84 22.84 22.54 22.71 35632 20100416 AYE 22.7 22.7 22.16 22.27 65517 20100419 AYE 22.2 22.34 22 22.05 51390 20100420 AYE 22.19 22.19 21.98 22.06 71382 20100421 AYE 22.07 22.19 21.95 21.98 30786 20100422 AYE 21.91 21.91 21.47 21.67 32906 20100423 AYE 21.71 21.73 21.51 21.57 49929 20100426 AYE 21.6 21.62 21.18 21.41 42379 20100427 AYE 21.32 21.74 21.19 21.2 25506 20100428 AYE 21.29 21.825 21.2 21.53 35948 20100429 AYE 21.61 21.95 21.42 21.49 36731 20100430 AYE 21.56 21.84 21.51 21.78 33993 20100503 AYE 21.86 22.04 21.53 21.9 29543 20100504 AYE 21.81 22 21.26 21.38 34547 20100505 AYE 21.23 21.29 20.72 20.75 47373 20100506 AYE 20.61 20.91 19.06 20.33 61439 20100507 AYE 20.35 20.49 19.86 19.95 69081 20100510 AYE 20.5 20.84 20.31 20.6 38721 20100511 AYE 20.39 20.75 20.37 20.47 25444 20100512 AYE 20.46 21.27 20.44 21.2 35555 20100513 AYE 21.19 22.05 21.02 21.58 44918 20100514 AYE 21.48 21.94 21.39 21.54 41641 20100517 AYE 21.51 21.51 20.77 21.04 32253 20100518 AYE 21.09 21.16 20.47 20.52 51254 20100519 AYE 20.5 20.62 20.21 20.48 27328 20100520 AYE 20.17 20.2 19.66 19.69 34516 20100521 AYE 19.5 19.92 19.3 19.9 26858 20100524 AYE 19.81 20.05 19.615 19.76 17349 20100525 AYE 19.39 19.52 18.965 19.49 26988 20100526 AYE 19.5 19.93 19.41 19.73 27189 20100527 AYE 19.98 20.27 19.81 20.24 20238 20100528 AYE 20.29 20.68 20.24 20.46 23409 20100601 AYE 20.3 20.3 19.63 19.63 20781 20100602 AYE 19.67 20.21 19.64 20.21 21671 20100603 AYE 20.15 20.72 20.06 20.62 29007 20100604 AYE 20.28 20.82 20.27 20.33 29893 20100607 AYE 20.28 21.06 20.28 20.76 29210 20100608 AYE 20.74 21.02 20.6 20.85 31774 20100609 AYE 20.93 20.97 20.59 20.65 19504 20100610 AYE 20.92 21.34 20.92 21.33 20394 20100611 AYE 21.15 21.35 21.036 21.34 8052 20100614 AYE 21.53 21.65 21.28 21.53 11503 20100615 AYE 21.65 21.87 21.62 21.84 11867 20100616 AYE 21.7 22.06 21.69 21.91 9299 20100617 AYE 21.95 22.31 21.805 22.26 15604 20100618 AYE 22.31 22.31 22.06 22.28 9785 20100621 AYE 22.46 22.49 21.7392 21.94 23755 20100622 AYE 21.98 21.98 21.15 21.2 21496 20100623 AYE 21.26 21.39 20.93 21.04 8429 20100624 AYE 20.98 21.44 20.86 21.05 15512 20100625 AYE 21.05\n\n---\n\nSII 27.52 27.55 26.5 26.8 80931 20091221 SII 27.19 27.47 27.01 27.11 38331 20091222 SII 27.12 27.32 26.965 27.24 38372 20091223 SII 27.53 27.66 27.23 27.45 29770 20091224 SII 27.61 27.64 27.21 27.25 12107 20091228 SII 27.51 27.75 27.21 27.31 17042 20091229 SII 27.56 27.56 27 27.2 22887 20091230 SII 27.08 27.35 26.98 27.26 18287 20091231 SII 27.43 27.51 27.03 27.17 15276 20100104 SII 27.67 28.05 27.62 27.99 42084 20100105 SII 28.16 28.97 28.07 28.83 58180 20100106 SII 28.87 30.09 28.67 30.06 70546 20100107 SII 29.73 30.34 29.7 30.25 34757 20100108 SII 30.1 31.2 29.91 31.12 37389 20100111 SII 31.51 31.57 30.4312 31.03 46454 20100112 SII 30.2 30.77 29.82 30.03 34684 20100113 SII 30.05 30.15 29.22 30.04 36123 20100114 SII 30.14 30.71 29.9 30.57 37486 20100115 SII 30.44 30.84 29.79 30.11 47121 20100119 SII 30.04 30.31 29.65 30.3 33438 20100120 SII 29.88 30.79 29.815 30.1 69635 20100121 SII 30.09 31.46 30.04 31.16 138175 20100122 SII 30.68 31.29 29.86 29.94 86628 20100125 SII 30.13 31 30.05 30.51 52942 20100126 SII 30.14 31.31 29.95 30.56 63769 20100127 SII 30.42 31.9 29.8899 30.97 82388 20100128 SII 31.35 31.42 30.37 30.81 66736 20100129 SII 31.17 31.98 30 30.32 70662 20100201 SII 30.72 31.65 30.43 31.58 39274 20100202 SII 31.73 32.1 31.49 31.7 46400 20100203 SII 31.7 32.31 31.21 31.55 31906 20100204 SII 31.08 31.08 30.23 30.35 48903 20100205 SII 30.4 30.75 29.14 30.28 56928 20100208 SII 30.4 30.95 29.9 30.21 38624 20100209 SII 30.72 31.71 30.49 31.05 57999 20100210 SII 31.09 31.79 30.51 31.79 48912 20100211 SII 31.68 32.32 31.16 32.18 45333 20100212 SII 31.58 32.04 31.23 31.97 37554 20100216 SII 32.47 33.02 32.34 32.86 33296 20100217 SII 33.03 33.33 32.78 33.05 30096 20100218 SII 32.95 33.49 32.61 33.35 41535 20100219 SII 37.97 38.16 36.95 37.7 428065 20100222 SII 40.03 41.305 39.84 41.03 1219686 20100223 SII 41.03 41.21 40.22 40.76 418006 20100224 SII 40.89 41.14 40.4 40.85 253758 20100225 SII 40.21 40.84 39.7175 40.83 149670 20100226 SII 40.99 41.2 40.56 40.99 153903 20100301 SII 41.48 41.55 40.9 41.22 150998 20100302 SII 41.38 42.25 41.09 42.21 134324 20100303 SII 42.54 43 42.35 42.49 95638 20100304 SII 42.48 42.85 41.88 42.32 113936 20100305 SII 42.71 43.01 42.54 42.97 103075 20100308 SII 42.86 43.61 42.86 43.49 81072 20100309 SII 43.23 43.52 42.9 43.28 55624 20100310 SII 43.04 43.54 42.6 43.39 69833 20100311 SII 43.18 43.3 42.77 43.13 41569 20100312 SII 43.46 43.71 43.11 43.59 62126 20100315 SII 43.26 43.7 42.775 43.5 59596 20100316 SII 43.8 44.48 43.37 44.34 60357 20100317 SII 44.56 45.32 44.34 45.13 67270 20100318 SII 45 45.19 43.77 44.05 77458 20100319 SII 44.18 44.41 42.98 43.31 115298 20100322 SII 42.39 43.365 41.79 42.82 60385 20100323 SII 42.85 43.2 42.35 42.51 61552 20100324 SII 42.1 42.75 41.91 42.07 39172 20100325 SII 42.44 42.7 40.91 40.93 49321 20100326 SII 41.19 41.87 41.19 41.62 39405 20100329 SII 41.95 42.77 41.8 42.58 72144 20100330 SII 42.6 43.06 42.34 42.49 40373 20100331 SII 42.83 42.85 42.45 42.82 86548 20100401 SII 43.33 43.79 43.1775 43.59 57376 20100405 SII 43.97 44.71 43.7 44.43 47585 20100406 SII 44.37 45.28 44.36 45.11 52076 20100407 SII 44.99 45.08 44.3299 44.58 43982 20100408 SII 44.19 45.11 43.91 44.98 33176 20100409 SII 45.29 45.5 44.685 44.85 52604 20100412 SII 44.81 45.16 44.64 44.72 34271 20100413 SII 44.91 44.91 43.61 44.23 44747 20100414 SII 44.6 45.54 44.4107 45.4 44458 20100415 SII 45.25 45.64 44.94 45.51 23040 20100416 SII 44.93 45.38 43.74 44.37 55187 20100419 SII 43.96 44.47 43.47 43.98 38198 20100420 SII 44.68 45.89 44.58 45.79 47210 20100421 SII 45.77 46.19 45.27 45.83 42409 20100422 SII 45.15 46.08 44.99 45.91 45765 20100423 SII 47.32 49.44 46.87 49.15 73007 20100426 SII 49.2 49.37 48.73 48.99 49488 20100427 SII 48.72 48.96 47.05 47.27 59383 20100428 SII 47.56 47.9 46.51 47.79 54313 20100429 SII 48.55 49.66 48.21 48.83 201169 20100430 SII 49.03 49.2 46.6 47.76 170794 20100503 SII 47.76 48.29 46.94 47.76 115480 20100504 SII 46.71 47.47 45.9 46.15 71278 20100505 SII 45.12 45.92 44.39\n\n---\n\n14.76 14.08 14.23 40648 20100728 GCI 14.185 14.37 13.77 13.9 28940 20100729 GCI 14.04 14.18 13.1 13.25 63195 20100730 GCI 13.02 13.275 12.88 13.18 39478 20100802 GCI 13.51 13.86 13.31 13.69 42775 20100803 GCI 13.58 13.58 13.21 13.21 27861 20100804 GCI 13.32 13.46 13.16 13.41 37666 20100805 GCI 13.24 13.36 13.06 13.31 33977 20100806 GCI 13.1 13.39 13.01 13.15 32064 20100809 GCI 13.26 13.49 13.19 13.49 21682 20100810 GCI 13.32 13.42 13.07 13.29 28788 20100811 GCI 13 13.06 12.69 12.88 65489 20100812 GCI 12.58 12.87 12.5 12.78 44572 20100813 GCI 12.65 12.97 12.59 12.66 42588 20100816 GCI 12.51 12.77 12.34 12.6 29251 20100817 GCI 12.71 12.88 12.42 12.73 38361 20100819 GCI 12.71 12.85 12.5 12.54 65974 20100820 GCI 12.42 12.59 12.13 12.32 34491 20090821 GD 56.13 58.68 56.1 58.49 42043 20090824 GD 58.78 58.98 58.33 58.74 17813 20090825 GD 59.01 59.72 58.63 58.71 19038 20090826 GD 58.74 58.86 57.87 58.73 22353 20090827 GD 59.07 60 58.76 59.95 24808 20090828 GD 60.17 60.17 59.34 59.77 22941 20090831 GD 59.52 59.56 58.68 59.19 20779 20090901 GD 59.15 59.73 58.11 58.6 19186 20090902 GD 58.48 58.81 57.7105 58.13 18388 20090903 GD 58.4 58.83 57.36 58.8 20275 20090904 GD 58.83 60.71 58.83 60.48 26804 20090909 GD 63.07 63.52 61.68 62.19 30661 20090910 GD 62.3 62.73 61.42 62.53 22236 20090911 GD 62.79 63.43 62.4 63.34 20660 20090914 GD 63.2 63.2 62.43 63.1 20281 20090915 GD 63.2 63.26 62.75 63.13 15364 20090916 GD 63.25 63.31 62.19 63.29 21091 20090917 GD 63.03 64.86 62.84 64.43 32268 20090918 GD 64.58 64.845 63.88 64.61 21451 20090921 GD 64.11 64.53 63.46 63.64 19365 20090922 GD 63.87 64.24 63.49 63.86 24620 20090923 GD 64.1 64.11 63.1 63.23 19514 20090924 GD 63.41 63.41 61.93 62.28 20451 20090925 GD 62.02 63.11 61.81 62.99 32697 20090928 GD 64.11 64.83 63.64 64.54 23101 20090929 GD 64.51 65.16 64.16 64.47 20969 20090930 GD 65.32 65.32 63.46 64.6 33013 20091001 GD 64.4 64.74 63.1 63.15 41368 20091002 GD 62.78 63.3 62.63 63.08 29353 20091005 GD 64.62 65 63.76 64.77 30031 20091006 GD 65.12 66.05 65 65.92 26586 20091007 GD 65.63 65.86 64.85 65.51 25133 20091008 GD 65.98 66.08 65 65.28 25456 20091009 GD 65.25 66.16 65.01 66.16 13978 20091012 GD 66.27 66.47 65.26 65.61 10776 20091013 GD 65.37 65.9 65.11 65.59 14878 20091014 GD 66.29 67.04 65.67 66.85 17115 20091015 GD 66.76 67.44 66.54 67.32 18766 20091016 GD 67.02 67.9 66.53 67.75 24837 20091019 GD 67.9 68.84 67.67 68.7 20839 20091020 GD 68.32 68.37 67.04 67.63 25891 20091021 GD 67.68 68.4 66.62 66.7 17126 20091022 GD 66.7 67.819 66.65 67.75 18528 20091023 GD 67.99 67.99 66.21 66.6 16985 20091026 GD 66.66 67.72 65.82 65.96 24505 20091027 GD 66.01 67.08 65.69 65.78 27139 20091028 GD 64.98 65.93 64.22 64.3 37228 20091105 GD 64.06 65.92 64.06 65.39 21145 20091106 GD 65.25 65.82 64.77 65.58 16777 20091109 GD 65.9 67.41 65.82 67.31 17022 20091110 GD 67.04 67.59 66.38 66.56 18686 20091111 GD 66.9 67.52 66.8 66.97 16372 20091112 GD 66.83 67.72 66.54 66.72 12024 20091113 GD 66.88 68 66.58 67.68 12571 20091116 GD 67.86 68.74 67.64 68.21 20881 20091117 GD 68.26 68.26 67.59 67.94 10401 20091118 GD 67.92 68.06 67.1 67.34 14812 20091119 GD 67.15 67.15 65.84 66.38 16676 20091120 GD 66.23 66.7 65.96 66.47 18601 20091123 GD 66.87 67.7 66.77 67.52 11712 20091124 GD 67.42 67.52 66.75 67.32 13148 20091125 GD 67.45 68.3 66.8764 68.13 15845 20091127 GD 66.95 67.54 66.19 67.08 10646 20091130 GD 67.25 67.25 65.46 65.9 28469 20091201 GD 66.49 67.46 66.23 67.14 18502 20091202 GD 67.29 67.73 66.84 67.09 18931 20091203 GD 67.11 67.73 66.68 66.78 13996 20091204 GD 67.16 68.43 66.76 67.54 17174 20091207 GD 67.55 68.21 67.49 67.88 11078 20091208 GD 67.61 68.15 66.83 67.82 19593 20091209 GD 67.96 67.96 66.94 67.9 18602 20091210 GD 68.02 68.68 67.86 68.01 10704 20091211 GD 68.05 69.17 68.01 69.01 15083 20091214 GD 69.32 70.84 69.21 70.66 25695 20091215 GD 70.4 70.58 69.48 69.67 21585 20091216 GD 69.82 70.04 68.85 69.45 20950 20091217 GD 69.05 69.32 68.4 68.51 12420 20091218 GD 68.78 68.93 67.7502 68.24 23280 20091221 GD 68.51\n\n---\n\n4.71 4.74 125639 20100622 THC 4.74 4.83 4.68 4.7 85307 20100623 THC 4.71 4.84 4.6 4.77 119881 20100624 THC 4.76 4.8 4.6 4.62 122849 20100625 THC 4.64 4.72 4.58 4.71 87402 20100628 THC 4.72 4.82 4.65 4.66 123913 20100629 THC 4.59 4.59 4.39 4.43 165226 20100630 THC 4.41 4.54 4.34 4.34 145011 20100701 THC 4.47 4.47 4.05 4.31 207485 20100702 THC 4.31 4.38 4.06 4.15 110705 20100706 THC 4.27 4.45 4.24 4.32 158207 20100707 THC 4.31 4.37 4.21 4.33 82762 20100708 THC 4.37 4.5 4.31 4.48 101324 20100709 THC 4.48 4.6 4.41 4.57 53822 20100712 THC 4.58 4.62 4.455 4.58 88073 20100713 THC 4.61 4.66 4.51 4.56 63160 20100714 THC 4.54 4.65 4.46 4.58 64691 20100715 THC 4.57 4.78 4.52 4.75 81097 20100716 THC 4.71 4.72 4.47 4.49 74512 20100719 THC 4.51 4.59 4.47 4.55 58234 20100720 THC 4.48 4.61 4.43 4.6 54439 20100721 THC 4.63 4.63 4.28 4.3 85926 20100722 THC 4.35 4.42 4.26 4.28 89950 20100723 THC 4.29 4.46 4.28 4.41 55045 20100726 THC 4.44 4.6 4.39 4.56 72692 20100727 THC 4.63 4.65 4.43 4.47 65097 20100728 THC 4.46 4.5 4.34 4.38 83538 20100729 THC 4.37 4.6 4.37 4.41 124026 20100730 THC 4.36 4.65 4.34 4.6 93921 20100802 THC 4.64 4.78 4.57 4.59 120000 20100803 THC 4.6 4.6 4.25 4.39 240014 20100804 THC 4.4 4.67 4.4 4.62 117328 20100805 THC 4.59 4.64 4.44 4.44 92097 20100806 THC 4.42 4.47 4.36 4.42 58086 20100809 THC 4.44 4.54 4.37 4.52 32093 20100810 THC 4.45 4.58 4.42 4.5 60071 20100811 THC 4.41 4.46 4.28 4.3 80620 20100812 THC 4.27 4.34 4.18 4.2 63864 20100813 THC 4.21 4.26 4.17 4.17 43121 20100816 THC 4.14 4.23 4.1 4.13 47486 20100817 THC 4.15 4.31 4.15 4.24 66570 20100819 THC 4.23 4.28 4.15 4.17 56755 20100820 THC 4.15 4.26 4.12 4.23 46182 20090821 TIE 8.08 8.3 8.06 8.22 18571 20090824 TIE 8.31 8.45 8.12 8.19 17570 20090825 TIE 8.24 8.25 7.92 7.96 20993 20090826 TIE 8.01 8.13 7.84 8.06 22310 20090827 TIE 8.12 8.69 7.97 8.62 58091 20090828 TIE 8.7 8.82 8.32 8.53 45795 20090831 TIE 8.45 8.52 8.17 8.22 28326 20090901 TIE 8.25 8.34 7.87 7.88 35828 20090902 TIE 7.88 8.1001 7.67 7.97 25991 20090903 TIE 8.035 8.22 8 8.2 19421 20090904 TIE 8.25 8.35 8.1 8.35 22800 20090909 TIE 9.03 9.49 8.8299 9.41 65660 20090910 TIE 9.69 9.97 9.35 9.89 69913 20090911 TIE 10.01 10.29 9.6216 9.86 52976 20090914 TIE 9.7 9.99 9.62 9.95 24213 20090915 TIE 9.99 10.28 9.95 10.28 31627 20090916 TIE 10.46 10.63 10.34 10.49 35573 20090917 TIE 10.31 10.53 10.07 10.16 32131 20090918 TIE 10.24 10.26 9.97 10.12 23186 20090921 TIE 9.83 9.99 9.61 9.91 22199 20090922 TIE 10.16 10.41 10.09 10.24 25595 20090923 TIE 10.26 10.53 10.12 10.16 22358 20090924 TIE 10.15 10.234 9.6 9.72 34903 20090925 TIE 9.45 9.62 9.28 9.41 33316 20090928 TIE 9.42 9.72 9.34 9.67 21195 20090929 TIE 9.82 9.93 9.6 9.67 25873 20090930 TIE 9.8 9.83 9.46 9.59 26772 20091001 TIE 9.6 9.6 9.08 9.08 32456 20091002 TIE 8.95 9.3 8.89 9.03 28379 20091005 TIE 9.09 9.49 9.01 9.41 22203 20091006 TIE 9.64 9.89 9.5 9.73 25513 20091007 TIE 9.68 9.83 9.55 9.8 19751 20091008 TIE 10 10.35 9.9 10.22 34832 20091009 TIE 10.18 10.23 9.99 10.13 14416 20091012 TIE 10.22 10.38 10.18 10.22 15485 20091013 TIE 10.21 10.25 10.04 10.17 17090 20091014 TIE 10.31 10.55 10.22 10.53 33450 20091015 TIE 10.4 10.65 10.36 10.58 21269 20091016 TIE 10.42 10.51 10.17 10.27 23065 20091019 TIE 10.38 10.58 10.331 10.49 17352 20091020 TIE 10.61 10.62 10.25 10.43 22995 20091021 TIE 10.39 10.43 10.03 10.06 35452 20091022 TIE 9.99 10.05 9.62 9.94 36596 20091023 TIE 10.03 10.07 9.46 9.5 33822 20091026 TIE 9.6 9.8 9.23 9.25 28959 20091027 TIE 9.32 9.406 9 9.02 25428 20091028 TIE 9 9.05 8.385 8.41 42766 20091105 TIE 9.02 9.44 8.91 9.44 42742 20091106 TIE 9.31 9.62 9.12 9.19 35973 20091109 TIE 9.29 9.61 9.29 9.61 26100 20091110 TIE 9.58 9.6 9.28 9.49 20811 20091111 TIE 9.65 9.65 9.4 9.52 18701 20091112 TIE 9.43 9.52 9.16 9.21 20027 20091113 TIE 9.21 9.4 9.16 9.32 14891 20091116 TIE 9.7 10.28 9.55 10.25 50529 20091117 TIE 10.19 10.35 10.05 10.33 30944 20091118 TIE 10.33 10.41 10.081 10.19 23807 20091119 TIE 10.09 10.09 9.71 9.92 25575 20091120 TIE 9.79 9.98 9.6 9.96\n\n---\n\n29.39 27.87 28.25 173538 20090930 AET 28.14 28.49 27.34 27.83 102525 20091001 AET 27.77 28.38 27.54 27.58 63622 20091002 AET 27.33 27.5 26.5 26.73 62374 20091005 AET 27.04 27.06 26.47 26.62 59569 20091006 AET 26.84 26.84 26.22 26.26 120039 20091007 AET 26.52 27.28 26.4 27.06 79911 20091008 AET 26.1 26.38 25.53 25.86 124727 20091009 AET 25.91 26.48 25.86 25.96 96907 20091012 AET 26.22 26.64 26.13 26.42 60241 20091013 AET 26.38 26.48 25.35 25.54 93251 20091014 AET 25.92 26.24 25.65 26.03 68248 20091015 AET 26.08 26.08 25.41 25.72 73966 20091016 AET 25.7 25.86 25.19 25.22 58039 20091019 AET 25.23 25.57 24.94 25.25 67996 20091020 AET 25.31 25.95 25.28 25.6 75503 20091021 AET 26.15 26.65 25.28 25.32 66565 20091022 AET 25.44 25.85 25.31 25.62 51312 20091023 AET 25.9 26.18 25.9 26.07 71399 20091026 AET 26.13 26.29 25.07 25.27 77172 20091027 AET 25.26 26.58 25.15 26.18 83004 20091028 AET 26.06 26.06 25.23 25.32 69177 20091105 AET 28.05 28.75 28.04 28.6 70321 20091106 AET 28.48 29.22 28.36 29.16 63680 20091109 AET 28.75 29.98 28.21 29.82 93573 20091110 AET 29.69 29.96 29.42 29.8 53320 20091111 AET 30.09 30.09 29.28 29.87 61107 20091112 AET 29.95 29.98 29.18 29.31 47022 20091113 AET 29.39 29.82 29.31 29.43 40609 20091116 AET 29.59 29.98 29.39 29.65 50054 20091117 AET 29.46 29.73 29.15 29.27 44965 20091118 AET 29.06 29.48 29 29.21 42037 20091119 AET 28.99 29.08 28.07 28.69 52862 20091120 AET 28.55 28.82 28.25 28.4 53483 20091123 AET 28.85 29.66 28.81 29.48 45361 20091124 AET 29.5 29.86 28.99 29.76 40258 20091125 AET 29.5 29.88 29.41 29.76 25470 20091127 AET 28.76 29.62 28.62 29.44 19264 20091130 AET 29.67 29.67 28.61 29.11 47522 20091201 AET 29.24 29.96 29.11 29.82 37933 20091202 AET 29.89 29.91 29.44 29.76 36029 20091203 AET 29.8 29.98 28.59 28.65 44895 20091204 AET 29 29.82 28.76 28.98 62553 20091207 AET 29 30.42 28.85 29.89 62895 20091208 AET 29.63 30.77 29.51 30.47 69016 20091209 AET 30.92 31.26 30.2 30.47 75999 20091210 AET 30.59 32.19 30.59 32.04 99056 20091211 AET 31.65 32.55 31.65 31.76 59091 20091214 AET 32 33.19 32 32.4 68733 20091215 AET 32.13 33.39 32.13 33.25 68459 20091216 AET 33.53 34.19 33.17 33.5 69521 20091217 AET 33.56 33.56 32.17 32.77 78497 20091218 AET 32.95 33 32.36 32.51 68159 20091221 AET 32.64 34.91 32.64 34.04 111345 20091222 AET 34.08 34.44 33.89 33.93 46154 20091223 AET 34.11 34.34 33.69 33.76 38978 20091224 AET 34.11 34.2 33.36 33.78 21711 20091228 AET 33.88 34.02 33.21 33.44 24004 20091229 AET 33.36 33.68 32.68 32.86 37801 20091230 AET 32.58 32.75 31.94 32.15 62459 20091231 AET 32.12 32.4 31.61 31.7 25070 20100104 AET 32.06 33.08 31.87 33 56719 20100105 AET 32.94 33.1 32.26 32.53 45735 20100106 AET 32.5 32.75 32.25 32.4 43030 20100107 AET 31.91 33.55 31.75 33.43 61816 20100108 AET 33.34 33.37 32.54 32.7 52264 20100111 AET 32.77 33.2 32.6 32.74 36740 20100112 AET 32.63 32.76 30.31 30.61 195432 20100113 AET 30.5 31.09 29.62 30.75 104662 20100114 AET 30.43 31.44 30.41 31.41 66303 20100115 AET 31.25 32.01 30.95 31.36 97940 20100119 AET 32.3 33.25 32.2 32.66 130450 20100120 AET 33.1 33.65 32.05 32.48 110077 20100121 AET 32.58 32.77 31.55 31.88 78377 20100122 AET 31.68 32.31 31.17 31.3 70000 20100125 AET 31.73 31.79 30.85 30.97 54316 20100126 AET 30.84 30.84 30.17 30.5 75769 20100127 AET 30.28 31.08 30.06 30.43 62549 20100128 AET 30.56 31.05 30.1 30.36 66268 20100129 AET 30.54 30.54 29.79 29.97 58836 20100201 AET 30.09 30.4 29.25 29.77 71412 20100202 AET 29.71 30.38 29.5 30.28 52914 20100203 AET 30.12 30.48 29.54 30.33 55450 20100204 AET 30.11 30.23 29.17 29.23 61082 20100205 AET 28.78 30.38 28.75 29.61 127514 20100208 AET 30.09 30.33 29.17 29.2 53951 20100209 AET 29.57 29.7 28 28.97 99612 20100210 AET 28.83 29.07 27.94 28.65 87251 20100211 AET 28.65 28.9 28.3 28.85 39153 20100212 AET 28.55 28.7 28.12 28.63 55365 20100216 AET 28.89 29 28.14 28.75 51374 20100217 AET 28.88 30 28.83 29.61 75200 20100218 AET 29.16 29.9 29.15 29.74 47634 20100219 AET 29.3 29.64 28.86 28.93 53612 20100222 AET 28.68 29.91 28.6 29.35\n\n---\n\nSVU 15.41 15.41 15.15 15.19 35189 20090918 SVU 15.21 15.51 15.14 15.46 34116 20090921 SVU 15.41 15.51 15.16 15.34 27323 20090922 SVU 15.43 15.5 15.25 15.4 18041 20090923 SVU 15.34 15.73 15.15 15.34 22590 20090924 SVU 15.32 15.62 15.25 15.31 23519 20090925 SVU 15.31 15.63 15.2 15.24 33402 20090928 SVU 15.25 15.35 15.03 15.09 32711 20090929 SVU 15.12 15.37 14.93 15.2 27594 20090930 SVU 15.34 15.35 14.82 15.06 36408 20091001 SVU 15 15.09 14.59 14.72 35940 20091002 SVU 14.71 14.74 14.4 14.47 24230 20091005 SVU 14.44 14.75 14.4 14.66 21279 20091006 SVU 14.71 15.04 14.63 14.68 27463 20091007 SVU 14.72 14.96 14.58 14.92 25065 20091008 SVU 14.98 15.76 14.96 15.65 43469 20091009 SVU 15.05 15.37 14.91 15.2 33709 20091012 SVU 15.23 16.11 15.2 16.07 50807 20091013 SVU 15.34 15.63 15.3 15.46 55762 20091014 SVU 15.52 15.63 15.425 15.62 44950 20091015 SVU 15.61 16.2 15.45 16.2 75731 20091016 SVU 16.06 17.15 16.02 17 88719 20091019 SVU 17.01 17.589 16.86 16.93 93352 20091020 SVU 16.81 17.48 16.67 17.2 114499 20091021 SVU 17.12 17.1925 16.57 16.59 60375 20091022 SVU 16.57 16.95 16.15 16.82 50827 20091023 SVU 16.95 16.97 16.3 16.55 37574 20091026 SVU 16.54 16.74 16.25 16.35 30807 20091027 SVU 16.34 16.41 15.99 16.01 46834 20091028 SVU 16.01 16.35 15.84 15.85 45493 20091105 SVU 15.84 16.33 15.83 16.12 22956 20091106 SVU 16.06 16.56 16.03 16.52 27680 20091109 SVU 16.62 17.02 16.5 17 29999 20091110 SVU 16.84 17.07 16.82 16.83 29050 20091111 SVU 16.85 16.91 16.3 16.39 55984 20091112 SVU 16.46 16.58 15.88 15.9 57555 20091113 SVU 15.94 16.11 15.78 15.9 38420 20091116 SVU 15.93 16.04 15.68 15.81 41567 20091117 SVU 15.72 15.86 15.49 15.7 31462 20091118 SVU 15.71 15.71 15.45 15.53 23623 20091119 SVU 15.45 15.49 15.08 15.13 31730 20091120 SVU 15.09 15.15 14.9 14.94 37522 20091123 SVU 15.12 15.19 14.93 14.95 39790 20091124 SVU 14.98 15 14.6768 14.77 48388 20091125 SVU 14.77 14.89 14.6 14.88 51072 20091127 SVU 14.43 14.67 14.35 14.42 27493 20091130 SVU 14.08 14.18 13.72 13.83 85740 20091201 SVU 13.89 14.35 13.87 14.3 55206 20091202 SVU 14.31 14.45 14.14 14.26 31331 20091203 SVU 14.24 14.3 13.95 14.07 34673 20091204 SVU 14.23 14.58 14.11 14.5 44204 20091207 SVU 14.49 14.68 14.33 14.44 36986 20091208 SVU 13.91 14.17 13.1 13.18 84344 20091209 SVU 13.24 13.27 12.83 12.97 51551 20091210 SVU 13.04 13.33 13.04 13.24 50189 20091211 SVU 13.35 13.49 13.31 13.39 28457 20091214 SVU 13.47 13.5 13.17 13.23 25145 20091215 SVU 13.23 13.23 12.8 12.91 39162 20091216 SVU 12.91 13.29 12.82 12.83 56814 20091217 SVU 12.83 13 12.57 12.57 47891 20091218 SVU 12.64 12.7 12.4 12.48 55445 20091221 SVU 12.59 12.82 12.51 12.66 30735 20091222 SVU 12.77 12.88 12.67 12.82 30155 20091223 SVU 12.85 12.88 12.65 12.83 18313 20091224 SVU 12.86 12.95 12.76 12.9 8650 20091228 SVU 12.97 12.97 12.79 12.9 15237 20091229 SVU 12.93 12.93 12.625 12.63 20298 20091230 SVU 12.59 12.72 12.57 12.66 18302 20091231 SVU 12.65 12.92 12.63 12.71 31982 20100104 SVU 12.8 13 12.78 12.96 43914 20100105 SVU 12.99 13 12.6 12.74 50151 20100106 SVU 12.74 12.98 12.74 12.87 38132 20100107 SVU 12.82 12.98 12.73 12.9 30190 20100108 SVU 12.9 12.96 12.78 12.87 30905 20100111 SVU 12.95 12.95 12.68 12.92 45215 20100112 SVU 13.81 14.14 13.36 13.67 167377 20100113 SVU 13.76 14.0499 13.42 13.86 59558 20100114 SVU 13.9 14.4 13.81 14.33 80407 20100115 SVU 14.38 14.5 13.98 14.32 52679 20100119 SVU 14.42 14.95 14.4 14.81 74295 20100120 SVU 14.71 15.675 14.63 15.62 86914 20100121 SVU 15.63 15.78 15.17 15.22 76088 20100122 SVU 15.23 15.54 14.99 15.42 70106 20100125 SVU 15.53 15.59 15.01 15.08 53692 20100126 SVU 15.02 15.04 14.75 14.75 33486 20100127 SVU 14.76 14.94 14.525 14.94 53385 20100128 SVU 14.94 15.12 14.66 15.05 50511 20100129 SVU 15.12 15.15 14.62 14.71 43821 20100201 SVU 14.72 14.99 14.72 14.84 33537 20100202 SVU 14.89 15.0995 14.78 15.06 39829 20100203 SVU 15 15.02 14.65 14.73 34319 20100204 SVU 14.62 14.83 14.41 14.44 44919 20100205 SVU 14.39 14.6 14.3 14.59 38565 20100208 SVU 14.61 14.635 14.32 14.42 26670 20100209 SVU\n\n---\n\nIBM 128.23 128.75 127.65 128.25 49047 20100401 IBM 128.95 129.31 127.55 128.25 49806 20100405 IBM 128.38 129.8 128.14 129.35 41188 20100406 IBM 128.68 129.3 128.05 128.93 39264 20100407 IBM 128.53 129.27 128.01 128.48 51573 20100408 IBM 128.04 128.23 127.2 127.61 60068 20100409 IBM 127.88 128.87 127.12 128.76 51865 20100412 IBM 128.57 128.956 128.24 128.36 39941 20100413 IBM 128.26 129.435 127.84 129.03 68218 20100414 IBM 129.73 131.42 129.46 131.25 85458 20100415 IBM 130.53 131.14 130.1902 130.89 64253 20100416 IBM 130.68 132.17 130.25 130.63 95497 20100419 IBM 130.38 132.28 130.38 132.23 113536 20100420 IBM 129.2 130.33 128.26 129.69 152185 20100421 IBM 129.87 130.27 128.5 128.99 75600 20100422 IBM 128.64 129.36 127.77 129.13 60186 20100423 IBM 129.08 130.1 128.71 129.99 61973 20100426 IBM 129.76 131.04 129.54 130.73 52854 20100427 IBM 129.9 132 128.71 128.82 109175 20100428 IBM 129.4 130.47 129.03 130.1 71236 20100429 IBM 130.55 131.21 130.15 130.46 57868 20100430 IBM 130.43 130.636 128.84 129 62666 20100503 IBM 129.39 130.14 128.8 129.6 49920 20100504 IBM 128.89 128.93 126.5754 128.12 82852 20100505 IBM 127.12 128.23 126.87 127.46 60728 20100506 IBM 126.29 127.93 116 123.92 131696 20100507 IBM 123.09 124.39 120 122.1 105853 20100510 IBM 126.27 126.67 125.06 126.27 84642 20100511 IBM 125.21 128.42 125.15 126.89 64997 20100512 IBM 127.16 132.85 127.01 132.68 166297 20100513 IBM 130.93 133.1 130.85 131.48 104983 20100514 IBM 131.06 131.67 129.41 131.19 99205 20100517 IBM 130.68 131.76 128.7 130.44 89247 20100518 IBM 131.26 131.99 129.9 129.95 93321 20100519 IBM 129.37 130.5 127.82 128.86 86698 20100520 IBM 127.22 127.96 123.68 123.8 131781 20100521 IBM 122.16 125.61 121.4 125.42 126395 20100524 IBM 125.26 126.02 124.04 124.45 68678 20100525 IBM 121.47 124.95 121.47 124.52 94988 20100526 IBM 124.89 125.94 123 123.23 90859 20100527 IBM 124.86 126.39 124.77 126.39 77265 20100528 IBM 125.96 126.2794 124.29 125.26 74223 20100601 IBM 124.69 126.88 124.2 124.34 71360 20100602 IBM 124.85 127.5 124.35 127.41 77055 20100603 IBM 127.75 128.22 126.46 127.96 66452 20100604 IBM 126.37 127.1 124.67 125.28 96691 20100607 IBM 125.57 125.86 124.13 124.13 69513 20100608 IBM 124.26 124.46 122.82 123.72 83991 20100609 IBM 124.74 125.84 123.58 123.9 78003 20100610 IBM 125.99 128.22 125.8 127.68 74796 20100611 IBM 126.73 128.8 126.44 128.45 58270 20100614 IBM 128.5 129.97 128.49 128.5 67531 20100615 IBM 128.8 129.95 128.37 129.79 66526 20100616 IBM 128.34 130.68 128.34 130.35 64009 20100617 IBM 130.07 131.03 129.86 130.98 55751 20100618 IBM 131.02 131.25 130.13 130.15 95815 20100621 IBM 131.42 131.94 130.22 130.65 68578 20100622 IBM 130.37 131.47 129.07 129.3 60306 20100623 IBM 129.25 131.47 129.09 130.11 68557 20100624 IBM 129.57 129.73 127.7 128.19 55655 20100625 IBM 128.54 129.095 127.12 127.12 104206 20100628 IBM 127.65 129.47 127.22 128.98 63351 20100629 IBM 127.35 128.4 124.12 125.09 93787 20100630 IBM 124.83 125.22 123 123.48 80179 20100701 IBM 123.85 124.21 121.61 122.57 97422 20100702 IBM 123.29 123.29 120.61 121.86 64544 20100706 IBM 123.67 124.63 122.17 123.46 63487 20100707 IBM 123.89 127.12 123.47 127 70902 20100708 IBM 127.37 128.15 126.74 127.97 54399 20100709 IBM 127.9 128.2 127.29 127.96 38984 20100712 IBM 127.37 128.83 127.16 128.67 42068 20100713 IBM 128.97 130.98 128.69 130.48 66876 20100714 IBM 129.32 131.6 129.14 130.72 66071 20100715 IBM 129.87 130.92 129.55 130.72 61875 20100716 IBM 129.96 130.15 127.85 128.03 70028 20100719 IBM 128.67 130.38 128.37 129.79 83885 20100720 IBM 122.97 126.56 122.93 126.55 163403 20100721 IBM 126.44 126.5 124.62 125.27 86154 20100722 IBM 126.32 127.78 126.05 127.47 69090 20100723 IBM 127.3 128.8 127 128.38 50779 20100726 IBM 127.83 128.43 127.14 128.41 51722 20100727 IBM 128.78 129.17 127.89 128.63 46485 20100728 IBM 128.67 129.35 127.88 128.43 42526 20100729 IBM 129.06 129.5 127.14 128.02 89973 20100730 IBM 127.43 128.98 127.04 128.4 60258 20100802 IBM 129.32 131.2 129.25 130.76 64374 20100803\n\n---\n\n14.63 14.71 13.92 13.93 38025 20091028 JNS 13.88 14.0196 12.9298 12.93 51663 20091105 JNS 13.2 13.33 12.89 13.26 44846 20091106 JNS 13.01 13.34 12.87 13.32 24762 20091109 JNS 13.52 14.11 13.49 13.98 28337 20091110 JNS 13.96 14.12 13.66 13.77 18584 20091111 JNS 13.93 14.2 13.9 14.01 24271 20091112 JNS 14.01 14.24 13.6 13.61 24415 20091113 JNS 13.66 13.9 13.48 13.72 16561 20091116 JNS 13.91 14.17 13.87 14.01 26405 20091117 JNS 13.93 14.09 13.85 14.04 12403 20091118 JNS 14.04 14.11 13.77 13.8 13494 20091119 JNS 13.69 13.76 13.26 13.47 15474 20091120 JNS 13.35 13.42 13.06 13.21 16535 20091123 JNS 13.46 13.59 13.08 13.35 28787 20091124 JNS 13.28 13.35 13 13.27 21086 20091125 JNS 13.46 13.46 13.07 13.27 16080 20091127 JNS 12.78 12.92 12.42 12.7 11976 20091130 JNS 12.77 13.14 12.6 13.09 32103 20091201 JNS 13.28 13.28 12.815 13.1 31939 20091202 JNS 13.21 13.23 12.77 12.87 28060 20091203 JNS 12.9 13.07 12.56 12.6 26791 20091204 JNS 12.91 13.17 12.54 12.97 32266 20091207 JNS 12.88 13.04 12.71 12.76 15436 20091208 JNS 12.66 12.71 12.49 12.66 22026 20091209 JNS 12.63 12.78 12.45 12.71 19276 20091210 JNS 12.78 12.96 12.71 12.8 14487 20091211 JNS 12.73 13.05 12.73 13.01 15562 20091214 JNS 13 13.07 12.76 12.97 13839 20091215 JNS 12.81 12.96 12.76 12.82 11888 20091216 JNS 12.94 13.28 12.915 13.21 18180 20091217 JNS 13.11 13.19 12.94 12.95 16484 20091218 JNS 13.02 13.17 12.87 13.17 18985 20091221 JNS 13.18 13.41 13.13 13.36 14154 20091222 JNS 13.38 13.49 13.3462 13.42 10141 20091223 JNS 13.39 13.5 13.15 13.31 10176 20091224 JNS 13.34 13.54 13.3 13.5 3608 20091228 JNS 13.5 13.76 13.41 13.47 7621 20091229 JNS 13.56 13.61 13.44 13.52 5262 20091230 JNS 13.43 13.58 13.32 13.44 5232 20091231 JNS 13.49 13.67 13.4 13.45 7750 20100104 JNS 13.61 13.94 13.46 13.83 13910 20100105 JNS 13.75 14.32 13.62 14.28 22689 20100106 JNS 14.26 14.47 14.2 14.33 18168 20100107 JNS 14.36 14.46 13.88 14.05 20523 20100108 JNS 13.93 14.34 13.86 14.31 22923 20100111 JNS 14.36 15.19 14.36 15 40448 20100112 JNS 14.86 14.97 14.45 14.55 18291 20100113 JNS 14.61 14.72 14.51 14.63 10937 20100114 JNS 14.57 14.81 14.27 14.67 13236 20100115 JNS 14.69 14.83 14.42 14.5 17475 20100119 JNS 14.47 14.69 14.26 14.69 17607 20100120 JNS 14.56 14.7 14.2 14.35 18350 20100121 JNS 14.3 14.56 13.79 13.86 35741 20100122 JNS 13.86 13.93 12.99 13.01 36890 20100125 JNS 13.23 13.61 13.18 13.42 31845 20100126 JNS 13.27 13.42 12.97 12.98 23317 20100127 JNS 12.68 13.26 12.37 13.18 59471 20100128 JNS 13.01 13.72 12.22 12.93 63979 20100129 JNS 13.03 13.25 12.15 12.21 43829 20100201 JNS 12.19 12.54 12.19 12.51 22698 20100202 JNS 12.55 12.64 12.14 12.14 45994 20100203 JNS 12.06 12.25 12 12.12 49567 20100204 JNS 12.39 12.39 11.49 11.66 84584 20100205 JNS 11.66 12.035 11.52 11.98 76422 20100208 JNS 11.95 12.22 11.65 11.67 35197 20100209 JNS 11.89 12.02 11.61 11.83 36434 20100210 JNS 11.81 12.11 11.76 11.94 18398 20100211 JNS 11.89 12.01 11.73 11.98 16290 20100212 JNS 11.85 11.97 11.77 11.95 22120 20100216 JNS 12.08 12.48 12.06 12.39 22109 20100217 JNS 12.43 12.5 12.28 12.41 18595 20100218 JNS 12.32 12.46 12.17 12.41 23764 20100219 JNS 12.37 12.55 12.34 12.41 16143 20100222 JNS 12.47 12.49 12.3 12.36 16081 20100223 JNS 12.29 12.38 11.98 12.09 21715 20100224 JNS 12.24 12.38 12.11 12.21 18019 20100225 JNS 12.02 12.12 11.78 11.99 38128 20100226 JNS 12.05 12.51 11.97 12.5 27597 20100301 JNS 12.53 12.92 12.5 12.91 25409 20100302 JNS 12.95 13.27 12.85 13.04 20816 20100303 JNS 13.12 13.48 13.08 13.24 23877 20100304 JNS 13.24 13.41 13.15 13.27 14857 20100305 JNS 13.38 13.74 13.36 13.67 27229 20100308 JNS 13.66 13.93 13.58 13.7 22704 20100309 JNS 13.58 13.9 13.4 13.78 26433 20100310 JNS 13.82 13.98 13.76 13.95 23385 20100311 JNS 13.64 13.98 13.54 13.77 15830 20100312 JNS 13.83 14.02 13.68 13.98 18788 20100315 JNS 13.98 14.03 13.75 14 24969 20100316 JNS 14.05 14.1 13.87 14 14858 20100317 JNS 14.07 14.4 14.07 14.35 26312 20100318 JNS 14.26 14.4 14.23 14.37 16775 20100319 JNS 14.31 14.41 14.01 14.02 24438 20100322 JNS\n\n---\n\n15.32 14.642 15.26 68199 20100726 GNW 15.25 15.69 15.12 15.55 74860 20100727 GNW 15.79 15.88 15.52 15.65 72642 20100728 GNW 15.51 15.8 15.45 15.56 62248 20100729 GNW 15.66 16.1 15.18 15.79 136354 20100730 GNW 14.59 14.7 13.22 13.58 372169 20100802 GNW 13.73 13.76 13.1 13.67 158335 20100803 GNW 13.55 13.69 13.19 13.26 101763 20100804 GNW 13.31 13.4 12.73 12.83 168259 20100805 GNW 12.8 13.35 12.58 13.24 144633 20100806 GNW 13.08 13.24 12.75 13.05 136873 20100809 GNW 13.18 13.24 12.94 13.18 54098 20100810 GNW 12.95 13.22 12.79 13.12 85306 20100811 GNW 12.75 12.87 12.28 12.37 96906 20100812 GNW 12.04 12.25 11.75 11.89 126207 20100813 GNW 11.91 12.11 11.8 11.9 85609 20100816 GNW 12.04 12.295 11.95 12.03 69250 20100817 GNW 12.19 12.41 11.96 11.97 69573 20100819 GNW 11.92 12.03 11.53 11.54 73366 20100820 GNW 11.42 11.535 11.21 11.36 66282 20090821 GOOG 464.84 466.09 462.65 465.24 35643 20090824 GOOG 467.08 470.09 464.425 468.73 24593 20090825 GOOG 469.09 474.35 468.72 471.37 23430 20090826 GOOG 472.6 473 466.7 468 19884 20090827 GOOG 466.58 468.58 460.73 466.06 20000 20090828 GOOG 469.02 472.37 463.38 464.75 17718 20090831 GOOG 459.56 461.86 458 461.67 19579 20090901 GOOG 459.95 466.82 454.42 455.761 25950 20090902 GOOG 454.5 458.33 452.59 453.01 18065 20090903 GOOG 456.32 458.25 455 457.52 16463 20090904 GOOG 458.07 462.6 455.78 461.3 14998 20090909 GOOG 459.34 466.27 458.8 463.97 21954 20090910 GOOG 466.01 470.94 462 470.94 25353 20090911 GOOG 470.71 473.3 467.63 472.14 19028 20090914 GOOG 470.25 476.8 470.05 475.12 19776 20090915 GOOG 475.12 478.91 472.71 477.54 23986 20090916 GOOG 479.92 489.37 478.48 488.29 25873 20090917 GOOG 490.66 497.37 487.15 491.72 44834 20090918 GOOG 496.86 496.98 491.23 491.46 32842 20090921 GOOG 486.22 498.9 486.22 497 21175 20090922 GOOG 500.35 501.99 497.81 499.06 30418 20090923 GOOG 500.92 507 497.71 498.46 27046 20090924 GOOG 500.53 501.41 493 496.77 25286 20090925 GOOG 495.48 499.93 492 492.48 20520 20090928 GOOG 495 501.5 493.295 498.53 18431 20090929 GOOG 499.15 499.75 493.01 498.53 20993 20090930 GOOG 499.76 500.14 487.24 495.85 31417 20091001 GOOG 493.99 496.47 487 487.2 28162 20091002 GOOG 483.79 491.74 482.6 484.58 26008 20091005 GOOG 487.67 492.43 483.34 488.52 21264 20091006 GOOG 492.37 499.37 491.7001 498.74 27329 20091007 GOOG 498.97 518.99 497.81 517.54 48776 20091008 GOOG 519.58 523.25 513.34 514.18 43065 20091009 GOOG 516.435 521.51 514.5 516.25 27398 20091012 GOOG 523 525.76 519.3201 524.04 33243 20091013 GOOG 525.02 527.46 521.38 526.11 30422 20091014 GOOG 532.26 535.58 530 535.32 32650 20091015 GOOG 533.74 536.9 527.27 529.91 61003 20091016 GOOG 547.16 554.75 544.53 549.85 88457 20091019 GOOG 553.09 553.6 548.73 552.09 32201 20091020 GOOG 551.64 552.95 540.7 551.72 40444 20091021 GOOG 550.48 559.35 549 551.1 36731 20091022 GOOG 550.69 555 548 554.09 23370 20091023 GOOG 554.99 557.89 551.2 553.69 23931 20091026 GOOG 556.55 561.64 550.89 554.21 29737 20091027 GOOG 552.56 554.56 544.16 548.29 32180 20091028 GOOG 546.51 550 538.25 540.3 25686 20091105 GOOG 543.94 549.77 542.664 548.65 18480 20091106 GOOG 547.72 551.78 545.5 551.1 18267 20091109 GOOG 554.99 562.58 554.23 562.51 26514 20091110 GOOG 563.39 568.78 562 566.76 22314 20091111 GOOG 570.5 573.5 565.86 570.56 23218 20091113 GOOG 569.4 572.51 566.61 572.05 16680 20091116 GOOG 573.58 576.99 572.78 576.28 21991 20091117 GOOG 574.06 577.5 573.72 577.49 19207 20091118 GOOG 577.49 578.78 572.07 576.65 15501 20091119 GOOG 573.89 574 570 572.99 21683 20091120 GOOG 569.99 571.6 569.4 569.964 20062 20091123 GOOG 576.41 586.6 575.86 582.35 25485 20091124 GOOG 582.5 584.29 576.54 583.09 16086 20091125 GOOG 586.44 587.0599 582.69 585.74 14614 20091127 GOOG 571.58 582.46 570.97 579.76 13845 20091130 GOOG 579.97 583.67 577.11 583 17252 20091201 GOOG 588.19 591.22 583 589.87 23212 20091202 GOOG 590.98 593.01 586.22 587.51 16652 20091203 GOOG 588.89 591.45 585 585.74 14293 20091204 GOOG 593.04 594.832 579.18 585.01 25140 20091207 GOOG 584.14\n\n---\n\nTXT 16.31 17.18 16.23 17.17 68334 20100708 TXT 17.12 17.3 16.66 17.04 50855 20100709 TXT 17.07 17.89 17.05 17.8 54789 20100712 TXT 17.8 18.03 17.48 17.68 39380 20100713 TXT 18.41 18.9 18.2 18.39 49484 20100714 TXT 18.25 18.5 17.9 18.25 42276 20100715 TXT 18.28 18.47 17.625 18.26 40429 20100716 TXT 18.09 18.14 17.29 17.34 54499 20100719 TXT 17.53 17.64 17.28 17.57 38276 20100720 TXT 17.16 18.19 17.1 18.08 42204 20100721 TXT 19.7 19.85 18.975 19.65 155576 20100722 TXT 19.99 20.37 19.79 20.22 74578 20100723 TXT 20.02 20.79 19.77 20.77 53000 20100726 TXT 20.88 21.21 20.65 21.17 44362 20100727 TXT 21.36 21.4 20.35 20.71 52125 20100728 TXT 20.71 20.97 20.39 20.63 49929 20100729 TXT 20.86 20.99 20.4 20.69 37648 20100730 TXT 20.26 20.86 20.23 20.76 37197 20100802 TXT 21.25 21.33 20.33 21.29 47068 20100803 TXT 21.25 21.32 20.91 21.09 22547 20100804 TXT 21.09 21.52 21.05 21.48 31565 20100805 TXT 21.25 21.46 21.08 21.36 21589 20100806 TXT 20.93 21.23 20.6 20.82 46106 20100809 TXT 21.03 21.1 20.61 20.98 35235 20100810 TXT 20.61 20.615 19.95 20.12 60700 20100811 TXT 19.59 19.59 18.59 18.97 81755 20100812 TXT 18.51 18.78 18.37 18.43 72333 20100813 TXT 18.36 18.7 18.15 18.16 68450 20100816 TXT 18 18.22 17.83 17.86 61856 20100817 TXT 18.12 18.73 18 18.37 62777 20100819 TXT 18.4 18.8 18 18.15 56009 20100820 TXT 18 18.06 17.49 17.89 60308 20090821 UNH 28.72 29.05 28.27 28.92 81828 20090824 UNH 29.09 29.72 28.55 29.69 119079 20090825 UNH 29.77 30 29.18 29.92 102078 20090826 UNH 29.83 29.84 28.81 28.93 101440 20090827 UNH 28.82 29.21 28.52 28.94 77841 20090828 UNH 29.1 29.13 27.98 28.18 90744 20090831 UNH 27.97 28.79 27.7 28 76038 20090901 UNH 27.94 28.47 27.27 27.33 101709 20090902 UNH 27.37 29.13 27.36 28.66 143803 20090903 UNH 28.94 29.1 28.03 28.87 104795 20090904 UNH 28.8 29.25 28.55 28.88 58374 20090909 UNH 28.02 28.44 27.7 28.4 109749 20090910 UNH 28.15 29.18 28.05 29.11 91364 20090911 UNH 29.12 29.41 28.77 29.07 54305 20090914 UNH 28.85 29.17 28.43 28.76 73561 20090915 UNH 28.82 28.83 27.66 27.7 135709 20090916 UNH 27.95 29.34 27.81 29.29 141190 20090917 UNH 29.45 29.88 29.13 29.34 114612 20090918 UNH 28.89 29.26 28.41 28.58 156995 20090921 UNH 28.45 28.94 28.22 28.59 82583 20090922 UNH 28.72 28.78 27.51 27.58 129499 20090923 UNH 27.85 27.85 26.63 26.68 152269 20090924 UNH 26.73 27.04 25.98 26.03 139958 20090925 UNH 26.01 26.18 25.13 25.34 168390 20090928 UNH 25.44 26.09 25.36 25.8 87955 20090929 UNH 25.92 26.44 24.94 25.68 232162 20090930 UNH 25.15 25.6 24.52 25.04 229364 20091001 UNH 24.89 25.64 24.7 24.79 172111 20091002 UNH 24.68 24.91 23.95 24.28 112195 20091005 UNH 24.38 24.5 23.95 24.04 124358 20091006 UNH 24.46 24.59 23.82 24.38 111923 20091007 UNH 24.42 25.34 24.4 25.05 120816 20091008 UNH 24.29 24.43 23.5 24.16 245316 20091009 UNH 24.45 25.05 24.41 24.67 165554 20091012 UNH 24.81 25.52 24.81 25.23 139538 20091013 UNH 25.17 25.17 23.96 24.29 190105 20091014 UNH 24.62 24.93 24.35 24.87 98019 20091015 UNH 24.77 24.91 24.38 24.55 111235 20091016 UNH 24.71 24.9636 24.33 24.45 123669 20091019 UNH 24.57 24.99 24.41 24.92 102737 20091020 UNH 25.68 26.52 25.5 25.96 213930 20091021 UNH 25.97 26.07 25.03 25.12 119609 20091022 UNH 25.05 26 25.02 25.71 137571 20091023 UNH 26.1 26.22 25.6 25.85 82933 20091026 UNH 25.93 26.19 25.29 25.31 143477 20091027 UNH 25.3 26.8 25.19 26.5 204857 20091028 UNH 26.29 26.51 25.81 25.88 115060 20091105 UNH 27.95 28.38 27.67 28.21 119946 20091106 UNH 28.1 28.74 27.8 28.67 118920 20091109 UNH 28.31 29.24 28.2 29.13 117518 20091110 UNH 29 29.18 28.62 28.97 80632 20091111 UNH 28.99 29.43 28.66 29.37 87941 20091112 UNH 29.43 29.43 28.69 28.76 84073 20091113 UNH 28.88 29.35 28.85 29.08 62767 20091116 UNH 29.23 29.5 28.95 29.15 82814 20091117 UNH 28.96 29.18 28.79 28.97 61033 20091118 UNH 28.97 29.11 28.65 28.87 73275 20091119 UNH 28.66 28.72 27.87 28.63 69909 20091120 UNH 28.3 28.77 28.3 28.56 90091 20091123 UNH 28.94 29.58 28.93 29.08 96248 20091124 UNH 29.33 29.69 28.85 29.56 72410 20091125 UNH 29.58 29.74 29.37\n\n---\n\n110598 20091020 LSI 5.79 5.83 5.64 5.68 64299 20091021 LSI 5.62 5.77 5.5 5.51 87070 20091022 LSI 5.57 5.58 5.4 5.46 112487 20091023 LSI 5.56 5.63 5.31 5.35 103364 20091026 LSI 5.3 5.54 5.26 5.33 79343 20091027 LSI 5.33 5.41 5.09 5.12 115031 20091028 LSI 5.19 5.21 4.94 4.99 98602 20091105 LSI 5.19 5.22 5.04 5.2 74509 20091106 LSI 5.09 5.24 5.07 5.22 67337 20091109 LSI 5.27 5.48 5.25 5.46 67158 20091110 LSI 5.44 5.53 5.33 5.5 68937 20091111 LSI 5.54 5.67 5.49 5.56 58131 20091112 LSI 5.54 5.61 5.47 5.53 47453 20091113 LSI 5.49 5.62 5.46 5.59 40730 20091116 LSI 5.51 5.81 5.5 5.79 138971 20091117 LSI 5.71 5.86 5.7 5.85 57724 20091118 LSI 5.86 5.88 5.69 5.7 43437 20091119 LSI 5.49 5.57 5.38 5.51 110680 20091120 LSI 5.48 5.51 5.3505 5.47 53060 20091123 LSI 5.55 5.6 5.44 5.5 44806 20091124 LSI 5.45 5.55 5.38 5.45 55644 20091125 LSI 5.47 5.55 5.38 5.53 43284 20091127 LSI 5.37 5.48 5.3 5.42 27090 20091130 LSI 5.44 5.48 5.27 5.29 73631 20091201 LSI 5.4 5.6 5.38 5.58 73159 20091202 LSI 5.54 5.69 5.54 5.63 50662 20091203 LSI 5.65 5.7 5.59 5.62 38240 20091204 LSI 5.76 5.83 5.57 5.76 91471 20091207 LSI 5.76 5.79 5.66 5.68 50174 20091208 LSI 5.62 5.71 5.54 5.55 90223 20091209 LSI 5.54 5.62 5.4999 5.57 86862 20091210 LSI 5.55 5.66 5.49 5.57 66288 20091211 LSI 5.59 5.59 5.46 5.57 47554 20091214 LSI 5.59 5.65 5.54 5.64 30317 20091215 LSI 5.67 5.67 5.51 5.53 70626 20091216 LSI 5.53 5.7 5.5 5.6 39186 20091217 LSI 5.57 5.61 5.41 5.47 50401 20091218 LSI 5.55 5.68 5.51 5.61 89933 20091221 LSI 5.6 5.97 5.6 5.96 106236 20091222 LSI 5.88 6 5.87 5.9 72016 20091223 LSI 5.94 6.05 5.88 5.99 71226 20091224 LSI 5.97 6.14 5.97 6.03 26447 20091228 LSI 6.04 6.11 5.95 6 60300 20091229 LSI 6 6.06 5.82 5.96 54032 20091230 LSI 6.01 6.01 5.89 6 40642 20091231 LSI 5.98 6.05 5.9 6.01 58815 20100104 LSI 6.05 6.23 6.03 6.08 113356 20100105 LSI 6.11 6.21 6.06 6.11 70197 20100106 LSI 6.17 6.17 5.95 6.03 88475 20100107 LSI 6 6.08 5.92 5.96 103382 20100108 LSI 5.96 6.03 5.9 6.02 78159 20100111 LSI 6.02 6.17 6.01 6.14 97474 20100112 LSI 6.07 6.07 5.86 5.94 70465 20100113 LSI 5.94 6.03 5.8 6.02 88099 20100114 LSI 6.03 6.04 5.93 5.97 76501 20100115 LSI 5.96 5.99 5.83 5.86 68870 20100119 LSI 5.88 5.99 5.84 5.97 62071 20100120 LSI 5.92 5.95 5.85 5.86 70312 20100121 LSI 5.98 6.2 5.93 6.08 175344 20100122 LSI 6 6.05 5.7 5.73 149158 20100125 LSI 5.7 5.86 5.7 5.8 76226 20100126 LSI 5.78 5.86 5.73 5.74 59256 20100127 LSI 5.74 6.05 5.7 6 150246 20100128 LSI 5.52 5.66 5.26 5.45 238843 20100129 LSI 5.54 5.55 4.88 4.99 274536 20100201 LSI 5.23 5.23 5.01 5.19 138848 20100202 LSI 5.2 5.23 5.09 5.12 136474 20100203 LSI 5.09 5.19 5.05 5.17 247991 20100204 LSI 5.08 5.14 4.955 5.02 246978 20100205 LSI 5 5.18 4.96 5.15 158904 20100208 LSI 5.12 5.24 5.07 5.14 93117 20100209 LSI 5.23 5.34 5.16 5.28 122833 20100210 LSI 5.33 5.39 5.27 5.36 92763 20100211 LSI 5.32 5.43 5.31 5.4 100043 20100212 LSI 5.32 5.43 5.29 5.39 115181 20100216 LSI 5.42 5.65 5.3917 5.63 114943 20100217 LSI 5.65 5.68 5.45 5.57 104414 20100218 LSI 5.53 5.59 5.48 5.56 90537 20100219 LSI 5.54 5.67 5.52 5.64 67257 20100222 LSI 5.72 5.74 5.55 5.59 58947 20100223 LSI 5.59 5.5912 5.42 5.52 71619 20100224 LSI 5.6 5.6 5.445 5.51 85068 20100225 LSI 5.41 5.46 5.28 5.46 80537 20100226 LSI 5.43 5.45 5.33 5.39 61629 20100301 LSI 5.42 5.54 5.4 5.51 53798 20100302 LSI 5.51 5.68 5.48 5.53 88641 20100303 LSI 5.57 5.62 5.46 5.51 75261 20100304 LSI 5.47 5.6 5.47 5.55 61063 20100305 LSI 5.63 5.68 5.54 5.64 67927 20100308 LSI 5.61 5.63 5.53 5.55 55922 20100309 LSI 5.54 5.58 5.47 5.47 65903 20100310 LSI 5.51 5.65 5.46 5.62 60436 20100311 LSI 5.56 5.58 5.42 5.53 100486 20100312 LSI 5.55 5.6 5.48 5.57 88272 20100315 LSI 5.54 5.58 5.48 5.56 80656 20100316 LSI 5.56 5.83 5.56 5.82 108139 20100317 LSI 6.01 6.55 5.96 6.34 414836 20100318 LSI 6.32 6.38 6.18 6.35 227092 20100319 LSI 6.38 6.52 6.29 6.41 212452 20100322 LSI 6.34 6.69 6.28 6.64 163351 20100323 LSI 6.68 6.73 6.58 6.65 107654 20100324 LSI 6.62 6.64 6.42 6.45 112689 20100325 LSI 6.54 6.64 6.45 6.46\n\n---\n\n46485 20100728 IBM 128.67 129.35 127.88 128.43 42526 20100729 IBM 129.06 129.5 127.14 128.02 89973 20100730 IBM 127.43 128.98 127.04 128.4 60258 20100802 IBM 129.32 131.2 129.25 130.76 64374 20100803 IBM 130.03 131.04 129.33 130.37 50919 20100804 IBM 130.46 131.5 129.85 131.27 45730 20100805 IBM 130.69 131.98 130.53 131.83 45231 20100806 IBM 130.41 130.48 128.76 130.14 61378 20100809 IBM 130.79 132.34 130.4 132 61353 20100810 IBM 131.18 132.49 130.77 131.84 54716 20100811 IBM 130.69 130.69 129.461 129.83 63180 20100812 IBM 128 128.78 127.52 128.3 51323 20100813 IBM 127.96 128.46 127.33 127.87 46705 20100816 IBM 127.47 128.23 126.96 127.77 40091 20100817 IBM 128.83 129.85 127.905 128.45 42985 20100819 IBM 128.97 129.59 128.02 128.9 54025 20100820 IBM 128.72 128.98 126.96 127.5 62462 20090821 ICE 96 96.22 93.94 95.94 18903 20090824 ICE 96.74 98.58 94.11 94.28 19766 20090825 ICE 94.84 96.29 92.23 93.37 16747 20090826 ICE 93.01 93.09 91.4 92.98 14481 20090827 ICE 92.89 93.49 91.01 91.3 14475 20090828 ICE 92.09 93.67 91.36 93.41 13655 20090831 ICE 91.99 94.09 90.78 93.8 11549 20090901 ICE 93.7 95.3 91.27 91.36 13004 20090902 ICE 90.74 92.98 90.41 90.59 9982 20090903 ICE 91.5 91.79 88.49 89.94 11940 20090904 ICE 89.9 90.62 87.2 89.56 14874 20090909 ICE 90.71 90.97 88.39 88.87 13997 20090910 ICE 88.71 89.41 86.5 89.36 15442 20090911 ICE 89.36 89.6 87.4 88.19 9978 20090914 ICE 87.43 90.22 86.66 90.22 10458 20090915 ICE 90.01 91.35 88.24 90.42 13896 20090916 ICE 90.57 95.26 90.35 95.04 21600 20090917 ICE 94.98 97.98 94.46 96.37 17812 20090918 ICE 96.97 99.1 95.41 97.63 17939 20090921 ICE 96.45 97.86 90.5 96.89 9270 20090922 ICE 98.11 99.39 95.5 98.85 12694 20090923 ICE 98.75 100.73 97.41 97.42 14448 20090924 ICE 97.53 97.53 92.24 93.03 16375 20090925 ICE 92.31 92.8986 90.31 91.05 11093 20090928 ICE 91.49 95.28 91.32 94.99 11771 20090929 ICE 95.44 96.5 94.75 95.04 9344 20090930 ICE 95.6 99 94.816 97.19 22532 20091001 ICE 96.42 97.45 92.01 93.84 19628 20091002 ICE 93 94.28 91 91.32 18475 20091005 ICE 93.24 95.05 91.8 94.99 13838 20091006 ICE 95.96 96.44 94.31 95.49 10260 20091007 ICE 95.28 95.54 93.03 94.09 11571 20091008 ICE 94.91 94.91 93.17 93.37 14832 20091009 ICE 93.46 96.35 93 95.96 12517 20091012 ICE 96.38 96.96 94.61 95.6 7748 20091013 ICE 94.9 96.3 94.41 95.75 7526 20091014 ICE 96.99 98.5 96.1 97.29 17027 20091015 ICE 96.4 98.5 96.12 98.25 7311 20091016 ICE 99.02 106.25 99 105.84 36298 20091019 ICE 106.01 107.27 104.23 106.03 22363 20091020 ICE 105.47 107.92 104.93 105.95 12877 20091021 ICE 105.52 109.59 105.25 106.43 13021 20091022 ICE 106.16 107.97 105.5 106.56 7562 20091023 ICE 106.96 106.96 104.1 104.54 8860 20091026 ICE 104.75 107.45 102.93 103.25 6894 20091027 ICE 103.65 104.41 102.48 102.78 7254 20091028 ICE 102.73 104.22 100.52 100.61 10504 20091105 ICE 100.88 104.71 100.88 104.53 10169 20091106 ICE 103.76 106.2899 102.7619 106.01 10864 20091109 ICE 107.49 108.9 106.36 107.92 8578 20091110 ICE 107.16 107.92 106.14 107.45 8324 20091111 ICE 108.07 109.94 107.3 108.13 9126 20091112 ICE 107.55 109.5 107.34 107.83 7344 20091113 ICE 107.51 108.99 106.75 108.53 5444 20091116 ICE 108.99 111.35 108.58 110.03 8741 20091117 ICE 110.56 111.02 108.86 109.27 5471 20091118 ICE 109.51 109.75 108.5 109.4 5067 20091119 ICE 108.6 108.94 105.5 106.76 9458 20091120 ICE 106.1 107.31 105.09 106.77 6043 20091123 ICE 107.99 110.51 107.59 108.6 7304 20091124 ICE 108.63 108.64 106.23 107.47 4726 20091125 ICE 107.36 108.47 107.03 107.92 4190 20091127 ICE 105.24 106.72 104.22 104.82 4749 20091130 ICE 105.07 106.96 104.48 106.79 7184 20091201 ICE 107.75 108.48 106.5 107.81 5483 20091202 ICE 107.59 109.76 106.3 106.62 8502 20091203 ICE 107.01 107.43 104.8 105.09 7616 20091204 ICE 106.62 107.24 102.83 105.1 8679 20091207 ICE 104.81 104.81 102.25 104.03 10113 20091208 ICE 103.68 105.11 103.17 105.04 7489 20091209 ICE 105.04 105.9499 103.9 105.35 7319 20091210 ICE 103.92 107.999 103.92 106 9378 20091211 ICE 107.2 109.97 106.5 109.49 11333 20091214 ICE\n\n---\n\n22.71 24.48 141792 20100708 STI 24.96 24.96 24.05 24.67 82240 20100709 STI 24.55 25.54 24.46 25.46 54188 20100712 STI 25.24 25.48 24.8 25.18 33142 20100713 STI 25.54 26.365 25.5 26.18 63045 20100714 STI 25.93 25.93 24.98 25.46 69568 20100715 STI 25.58 25.58 24.42 25.19 68793 20100716 STI 24.82 24.82 23.13 23.31 108617 20100719 STI 23.38 23.53 22.59 23.37 64425 20100720 STI 22.81 23.08 22.44 23.07 96668 20100721 STI 23.46 23.86 22.32 22.42 92660 20100722 STI 24.01 24.89 23.65 24.58 122842 20100723 STI 24.36 25.15 24.02 25.04 71690 20100726 STI 25.18 26.42 24.88 26.38 87802 20100727 STI 26.68 27.05 26.16 26.27 72302 20100728 STI 26.1 26.3 25.83 25.99 47762 20100729 STI 26.25 26.42 25.51 25.96 59315 20100730 STI 25.53 26.13 25.42 25.95 44050 20100802 STI 26.6 26.76 26.19 26.63 47556 20100803 STI 26.49 26.7695 26.25 26.37 52466 20100804 STI 26.43 26.58 26 26.19 39665 20100805 STI 26.06 26.42 25.75 26.34 45802 20100806 STI 26.01 26.12 25.17 25.85 49495 20100809 STI 26 26.15 25.49 25.88 48330 20100810 STI 25.55 26.26 25.37 25.99 58689 20100811 STI 25.43 25.56 24.38 24.46 74825 20100812 STI 24.06 24.555 23.94 24.3 59428 20100813 STI 24.26 24.73 24.23 24.39 39538 20100816 STI 24.24 24.46 24.02 24.36 38629 20100817 STI 24.71 24.76 24.11 24.14 47747 20100819 STI 24.52 25.1 24.1875 24.22 70643 20100820 STI 24 24.24 23.59 24 53040 20090821 STJ 37.91 38.08 37.522 37.79 23219 20090824 STJ 38.02 38.13 37.54 37.92 13988 20090825 STJ 38 38.25 37.85 38.02 16751 20090826 STJ 38.78 39.63 38.45 38.65 41256 20090827 STJ 38.6 39 38.35 38.87 21273 20090828 STJ 39.01 39.08 38.5 38.85 21067 20090831 STJ 38.46 39.21 38.16 38.54 27349 20090901 STJ 38.4 38.8 37.59 37.97 34044 20090902 STJ 37.8 38.31 37.52 38.1 28950 20090903 STJ 37.975 38.42 37.94 38.31 21625 20090904 STJ 38.27 39.53 37.94 39.4 21067 20090909 STJ 38.4 39.45 38.36 38.99 26839 20090910 STJ 38.86 39.51 37.82 39.43 25304 20090911 STJ 39.39 39.55 38.91 39.01 33148 20090914 STJ 39.03 39.09 38.59 39.04 25634 20090915 STJ 39 39 37.96 38.34 42407 20090916 STJ 38.37 38.37 37.37 38 44102 20090917 STJ 37.87 38.34 37.66 38.29 46786 20090918 STJ 38.35 38.6 38.23 38.45 30324 20090921 STJ 38.29 39.45 38.11 39.23 34523 20090922 STJ 39.38 39.7 39.16 39.23 50520 20090923 STJ 39.14 39.46 38.69 39.04 34231 20090924 STJ 39.02 39.46 38.82 39.29 41933 20090925 STJ 39.14 39.41 38.75 39.22 19714 20090928 STJ 39.32 40.04 39.26 39.65 34682 20090929 STJ 39.78 39.95 39.49 39.74 16493 20090930 STJ 38.86 39.19 38.13 39.01 45154 20091001 STJ 38.97 38.97 38.11 38.39 34116 20091002 STJ 38.08 38.39 37.8 37.98 30309 20091005 STJ 38.01 38.37 37.59 38.24 13738 20091006 STJ 32.7 34.46 32.5 33.4 518107 20091007 STJ 33.71 33.96 32.925 33.01 128153 20091008 STJ 33.34 33.42 32.65 32.79 80710 20091009 STJ 32.98 34.31 32.68 34.1 86538 20091012 STJ 34.3 34.4 33.22 33.44 49680 20091013 STJ 33.53 33.65 33.18 33.27 40281 20091014 STJ 33.5 33.5 32.71 32.99 75429 20091015 STJ 32.88 33.62 32.88 33.6 41144 20091016 STJ 33.49 33.8705 33.26 33.83 35628 20091019 STJ 33.85 34.39 33.435 34.28 52408 20091020 STJ 33.54 33.66 31.66 33.16 161557 20091021 STJ 33.23 34.86 33.15 34.11 138110 20091022 STJ 33.98 34.64 33.71 34.43 78587 20091023 STJ 34.58 34.82 34.15 34.4 60890 20091026 STJ 34.48 34.97 34.3 34.75 67728 20091027 STJ 34.73 35.225 34.34 35.16 64881 20091028 STJ 34.91 35.03 34.33 34.33 55601 20091105 STJ 34.65 34.89 34.42 34.8 24814 20091106 STJ 34.57 35.09 34.48 34.79 24055 20091109 STJ 35.02 35.28 34.52 35.23 30265 20091110 STJ 35.1 35.64 34.87 35.39 29548 20091111 STJ 35.45 35.62 35.07 35.49 24028 20091112 STJ 35.24 35.48 34.34 34.74 43393 20091113 STJ 34.72 35.04 34.1 34.18 46321 20091116 STJ 34.33 34.83 34.3 34.46 33548 20091117 STJ 34.37 34.71 34.37 34.67 23118 20091118 STJ 34.72 35.27 34.66 35.06 27166 20091119 STJ 34.94 34.94 34.19 34.5 30326 20091120 STJ 34.38 34.66 34.25 34.32 36137 20091123 STJ 34.32 35.11 34.32 35.01 36417 20091124 STJ 35.1 36.84 35.01 36.42 81443 20091125 STJ 36.36 36.98 36.01 36.79 34595 20091127 STJ 36.17 36.61\n\n---\n\nQLGC 20.02 20.58 20.01 20.56 17157 20100324 QLGC 20.35 20.52 20.22 20.32 14140 20100325 QLGC 20.65 20.68 20.17 20.18 12204 20100326 QLGC 20.26 20.35 20.02 20.16 14125 20100329 QLGC 20.25 20.45 19.97 20.07 18847 20100330 QLGC 20 20.46 19.92 20.39 16918 20100331 QLGC 20.35 20.52 20.26 20.3 14058 20100401 QLGC 20.49 20.74 19.89 20.1 26535 20100405 QLGC 20.23 20.77 20.11 20.72 32973 20100406 QLGC 20.55 20.82 20.375 20.72 31325 20100407 QLGC 20.75 20.95 20.56 20.81 18819 20100408 QLGC 20.13 20.27 19.855 20.15 44993 20100409 QLGC 20.27 20.44 19.98 20.39 48266 20100412 QLGC 20.42 20.7 20.39 20.65 23701 20100413 QLGC 20.5 20.86 20.44 20.77 18468 20100414 QLGC 20.83 21.265 20.7225 21.2 25625 20100415 QLGC 21.11 21.41 21.03 21.31 11927 20100416 QLGC 21.12 21.305 20.7 21.09 29109 20100419 QLGC 21.06 21.15 20.5 20.94 29637 20100420 QLGC 21 21.34 20.845 21.19 16383 20100421 QLGC 21.12 21.55 21.12 21.52 15514 20100422 QLGC 21.29 22.18 21.13 22.13 22224 20100423 QLGC 22.09 22.34 21.87 22.31 18085 20100426 QLGC 22.31 22.4 22.03 22.07 19795 20100427 QLGC 21.72 21.89 21.18 21.22 43582 20100428 QLGC 21.25 21.45 20.9 21.02 39179 20100429 QLGC 21.14 21.65 21.06 21.58 29711 20100430 QLGC 20.3 20.55 19.21 19.37 86975 20100503 QLGC 19.51 20.1 19.49 19.93 31820 20100504 QLGC 19.61 19.66 19.05 19.5 35630 20100505 QLGC 19.46 19.93 19.22 19.6 35276 20100506 QLGC 19.61 19.9 17.62 18.99 33639 20100507 QLGC 18.92 19.17 18.22 18.5 40455 20100510 QLGC 19.43 19.87 19.08 19.56 30714 20100511 QLGC 19.23 19.415 19.02 19.13 36443 20100512 QLGC 19.27 19.81 19.25 19.74 21755 20100513 QLGC 19.85 19.93 19.34 19.35 22912 20100514 QLGC 19.31 19.31 18.64 18.96 33431 20100517 QLGC 19.14 19.27 18.52 18.99 34762 20100518 QLGC 19.23 19.24 18.56 18.57 34912 20100519 QLGC 18.57 18.83 18.17 18.5 30911 20100520 QLGC 17.96 18.32 17.71 17.85 31388 20100521 QLGC 17.51 18.15 17.49 18.01 36094 20100524 QLGC 17.79 18.26 17.76 17.94 24097 20100525 QLGC 17.55 17.86 17.17 17.86 25245 20100526 QLGC 17.92 18.215 17.53 17.57 36202 20100527 QLGC 17.92 18.435 17.85 18.35 30995 20100528 QLGC 18.3 18.47 18.045 18.12 29139 20100601 QLGC 18.07 18.36 17.91 17.91 28250 20100602 QLGC 17.86 18.33 17.855 18.31 18379 20100603 QLGC 18.24 18.48 18.11 18.4 23481 20100604 QLGC 17.79 18.3 17.44 17.55 28793 20100607 QLGC 17.55 17.75 16.92 16.97 30889 20100608 QLGC 16.99 17.01 16.44 16.7 42786 20100610 QLGC 16.66 16.84 16.42 16.82 39996 20100611 QLGC 16.66 17.19 16.39 17.03 44010 20100614 QLGC 17.13 17.41 16.98 17.04 30183 20100615 QLGC 17.23 17.76 17.14 17.76 29148 20100616 QLGC 17.7 17.87 17.52 17.75 24879 20100617 QLGC 17.84 18.06 17.55 17.92 24143 20100618 QLGC 17.99 18.2625 17.96 18.08 27537 20100621 QLGC 18.3 18.45 17.87 17.95 22196 20100622 QLGC 18.03 18.315 17.54 17.74 19710 20100623 QLGC 17.89 18.21 17.7 17.96 24302 20100624 QLGC 18 18 17.37 17.47 22383 20100625 QLGC 17.59 17.74 17.19 17.59 21834 20100628 QLGC 17.59 17.84 17.32 17.62 13054 20100630 QLGC 16.88 17.14 16.6 16.62 20230 20100701 QLGC 16.56 16.935 16.18 16.91 25953 20100702 QLGC 16.87 17.02 16.62 16.8 16869 20100706 QLGC 17.15 17.32 16.76 16.94 24613 20100707 QLGC 17.13 17.76 16.93 17.7125 21566 20100708 QLGC 17.78 18.13 17.71 18.03 17565 20100709 QLGC 18.04 18.17 17.88 18.13 14464 20100712 QLGC 17.99 18.44 17.97 18.22 12050 20100713 QLGC 18.44 18.68 18.215 18.58 12116 20100714 QLGC 18.67 19.075 18.59 18.74 18074 20100715 QLGC 18.7 18.89 18.43 18.83 14157 20100716 QLGC 18.78 18.78 18.19 18.29 17734 20100719 QLGC 18.29 18.47 18.09 18.4 13397 20100720 QLGC 18.16 18.53 17.82 18.5 15938 20100721 QLGC 18.61 18.82 18.37 18.6 33454 20100722 QLGC 18.56 19.18 18.56 18.85 44393 20100723 QLGC 16.59 16.77 15.59 15.76 146116 20100726 QLGC 15.77 16.02 15.51 15.98 60189 20100727 QLGC 16.085 16.37 15.81 16.26 52369 20100728 QLGC 16.26 16.34 15.95 16.04 31670 20100729 QLGC 16.29 16.29 15.72 15.93 25731 20100730 QLGC 15.77 16.045 15.67 15.92 26059 20100802 QLGC 16.19 16.37 16.08 16.29 21455 20100803 QLGC 16.22 16.25 15.8 15.85 39402 20100804 QLGC 16 16\n\n---\n\n26.38 26.66 6929 20090826 FII 26.46 26.69 26.39 26.52 5968 20090827 FII 26.59 26.71 26.09 26.49 6150 20090828 FII 26.57 26.74 26.12 26.43 3582 20090831 FII 26.12 26.28 25.73 26.25 5211 20090901 FII 26.15 26.29 25.34 25.46 10755 20090902 FII 25.3 25.6 25.08 25.43 8253 20090903 FII 25.63 25.7 25.05 25.34 19483 20090904 FII 25.44 25.48 24.88 25.37 9646 20090909 FII 26.09 26.68 25.93 26.65 7111 20090910 FII 26.54 26.63 25.95 26.31 9684 20090911 FII 26.285 26.32 25.6 25.66 9477 20090914 FII 25.47 26.33 25.41 26.31 8687 20090915 FII 26.24 26.25 25.89 26.08 6814 20090916 FII 26.06 27.02 25.99 26.89 12069 20090917 FII 26.88 27.31 26.83 26.94 7658 20090918 FII 27.2 27.22 26.78 26.98 9746 20090921 FII 26.82 26.9 26.61 26.62 5705 20090922 FII 26.89 27.27 26.6 27.19 8415 20090923 FII 27.22 27.5 26.66 26.66 8415 20090924 FII 26.52 26.55 25.48 25.65 14082 20090925 FII 25.69 25.69 24.97 25.29 10248 20090928 FII 25.4 25.98 25.27 25.97 6149 20090929 FII 26 26.41 25.95 26.24 7255 20090930 FII 26.27 26.62 26.09 26.37 7536 20091001 FII 26.21 26.42 25.13 25.15 15793 20091002 FII 24.92 25.06 24.76 24.99 12058 20091005 FII 25.16 26.05 24.93 26.04 12625 20091006 FII 26.3 26.3 25.5 25.88 12591 20091007 FII 25.66 25.95 25.61 25.87 11117 20091008 FII 26.09 26.28 25.87 25.97 6501 20091009 FII 25.88 26.14 25.81 26.03 5096 20091012 FII 26.16 26.32 25.7 25.94 4732 20091013 FII 25.92 25.96 25.63 25.74 4680 20091014 FII 26.22 26.75 26.03 26.62 10679 20091015 FII 26.55 26.69 26.44 26.62 7732 20091016 FII 26.14 26.25 25.82 25.97 8338 20091019 FII 26.01 26.34 25.81 26.19 5761 20091020 FII 26.17 26.42 25.92 26.22 9313 20091021 FII 26.1 26.64 25.75 25.83 10824 20091022 FII 25.83 26.99 25.66 26.86 15082 20091023 FII 27.29 27.91 26.945 27.39 20090 20091026 FII 27.37 27.99 27.37 27.52 18303 20091027 FII 27.5 28.1 27.4 27.53 15938 20091028 FII 27.57 27.75 26.7 26.73 15378 20091105 FII 26.49 26.61 26.19 26.58 8903 20091106 FII 26.39 26.7 26.2 26.62 7582 20091109 FII 26.8 27.29 26.66 27.27 6560 20091110 FII 27.18 27.38 26.97 27.22 6515 20091111 FII 27.45 27.7 27.37 27.55 6355 20091112 FII 27.53 27.72 27.25 27.26 7942 20091113 FII 27.26 27.55 27.06 27.54 6741 20091116 FII 27.79 28.05 27.73 27.91 11054 20091117 FII 27.91 27.96 27.6 27.69 12037 20091118 FII 27.6 27.67 27.13 27.35 12883 20091119 FII 27.2 27.28 26.72 26.94 9063 20091120 FII 26.83 26.85 26.59 26.64 10392 20091123 FII 26.98 26.98 25.97 26.1 20430 20091124 FII 26.25 26.81 25.86 26.05 17889 20091125 FII 26.23 26.29 26.02 26.1 9168 20091127 FII 25.5 25.83 25.41 25.6 7487 20091130 FII 25.66 25.87 25.51 25.78 12219 20091201 FII 25.99 26.18 25.8 26 9614 20091202 FII 26 26.13 25.68 25.78 12213 20091203 FII 25.92 26.11 25.67 25.73 11236 20091204 FII 26.11 26.15 25.355 25.78 11952 20091207 FII 25.67 25.8 24.98 25.01 19250 20091208 FII 24.92 25.11 24.81 24.96 9299 20091209 FII 24.94 25.4 24.86 25.28 8199 20091210 FII 25.43 25.56 25.31 25.33 5959 20091211 FII 25.4 25.45 25.15 25.36 7733 20091214 FII 25.42 25.44 25.05 25.22 8885 20091215 FII 25.14 25.14 24.87 25 13821 20091216 FII 25.14 25.73 25.04 25.7 11484 20091217 FII 25.51 25.88 25.49 25.76 15670 20091218 FII 25.98 26.47 25.98 26.47 20840 20091221 FII 26.58 27.11 26.41 27.05 12565 20091222 FII 26.97 27.69 26.96 27.69 14920 20091223 FII 27.69 28.3 27.68 27.96 13819 20091224 FII 27.99 28.31 27.81 28.02 2815 20091228 FII 28.02 28.19 27.87 27.94 4326 20091229 FII 27.99 28.06 27.72 27.79 7549 20091230 FII 27.68 27.87 27.56 27.87 5014 20091231 FII 27.84 28 27.5 27.5 7737 20100104 FII 27.76 28.03 27.44 28 13887 20100105 FII 27.97 28.14 27.67 28.01 10957 20100106 FII 27.94 28.03 27.7 27.81 6638 20100107 FII 27.72 27.93 27.49 27.58 10383 20100108 FII 27.67 27.67 27.32 27.57 8779 20100111 FII 27.76 27.9002 27.6 27.88 8162 20100112 FII 27.7 27.98 27.59 27.68 6493 20100113 FII 27.8 27.83 27.59 27.73 4771 20100114 FII 27.71 27.71 27.3002 27.5 5040 20100115 FII 27.43 27.55 27.22 27.3 7268 20100119 FII 27.4 27.76 27.25 27.75 6077 20100120 FII 27.44 27.62 27.21 27.48 6555 20100121\n\n---\n\n20091221 IP 26.81 27.45 26.77 27.01 35898 20091222 IP 27.18 27.49 27 27.4 25862 20091223 IP 27.41 27.79 27.26 27.66 20397 20091224 IP 27.69 27.75 27.32 27.45 8359 20091228 IP 27.49 27.68 27.03 27.28 16943 20091229 IP 27.36 27.67 27.04 27.22 15926 20091230 IP 27.08 27.33 26.94 27.23 27116 20091231 IP 27.19 27.41 26.78 26.78 14847 20100104 IP 27.19 27.45 27.04 27.18 39791 20100105 IP 27.17 28.45 27.01 28.14 51770 20100106 IP 27.65 28.61 27.63 27.82 57838 20100107 IP 27.67 27.7 26.67 26.76 69770 20100108 IP 26.76 27.03 26.23 26.93 45309 20100111 IP 27.24 27.24 26.36 26.61 44015 20100112 IP 26.28 27.52 26.28 26.68 80098 20100113 IP 26.75 27.02 26.38 26.62 36673 20100114 IP 26.58 26.6 26.09 26.23 32559 20100115 IP 26.19 26.56 25.7 26.08 48452 20100119 IP 26.12 26.99 25.92 26.96 45631 20100120 IP 26.62 26.79 25.95 26.28 35593 20100121 IP 26.42 26.48 24.44 24.45 75303 20100122 IP 24.54 25.02 23.8 24.43 85908 20100125 IP 25.08 25.42 24.45 24.5 48904 20100126 IP 24.24 24.9 24.2 24.47 43683 20100127 IP 24.3 24.35 23.13 23.88 76132 20100128 IP 24.03 24.03 22.63 23.07 67499 20100129 IP 23.27 23.53 22.82 22.91 42216 20100201 IP 23.24 23.93 23 23.9 55542 20100202 IP 23.94 24.32 23.65 24.02 64130 20100203 IP 22.79 23.24 22.12 22.67 152623 20100204 IP 22.77 22.77 21.85 22.15 97667 20100205 IP 22.15 22.73 21.66 22.67 118224 20100208 IP 22.6 23.05 22.125 22.51 74659 20100209 IP 22.95 23.3 22.5 22.92 67544 20100210 IP 22.91 23.01 22.05 22.41 59668 20100211 IP 22.28 22.66 22.17 22.37 68670 20100212 IP 22.19 22.6 21.68 22.57 66503 20100216 IP 22.77 24.15 22.77 24.1 102362 20100217 IP 24.05 24.47 23.55 23.71 59807 20100218 IP 23.56 24.45 23.51 24.23 47382 20100219 IP 24.03 24.59 23.85 24.25 45587 20100222 IP 24.44 24.44 23.32 23.99 53809 20100223 IP 24.02 24.88 23.87 24.01 70059 20100224 IP 24.01 24.31 23.77 23.9 39954 20100225 IP 23.5 24.03 23.29 23.89 52157 20100226 IP 23.86 23.97 23.12 23.17 66944 20100301 IP 23.4 24.21 23.3 24.18 59525 20100302 IP 24.38 25.16 23.5126 25.03 86252 20100303 IP 25.11 25.6 24.91 25.2 62322 20100304 IP 25.33 25.5 24.58 24.98 44022 20100305 IP 25.19 25.52 25.07 25.35 60176 20100308 IP 25.35 25.42 24.96 25.25 44131 20100309 IP 25.15 25.44 24.92 25.09 58301 20100310 IP 25.07 25.51 24.88 25.11 48369 20100311 IP 25 25.22 24.79 25.2 59009 20100312 IP 25.45 25.71 25.25 25.34 61449 20100315 IP 25.22 25.2887 24.74 24.91 48087 20100316 IP 25.11 25.5 25.03 25.38 79486 20100317 IP 25.48 27.29 25.48 27.02 156381 20100318 IP 26.86 26.99 26.14 26.42 69875 20100319 IP 26.7 26.73 25.74 25.82 68893 20100322 IP 25.81 26.16 25.55 26.05 80615 20100323 IP 26.05 26.2 25.8 26.16 89003 20100324 IP 26.1 26.47 25.82 26.21 91675 20100325 IP 26.5 26.58 25.21 25.21 78592 20100326 IP 25.38 25.625 24.95 24.99 91005 20100329 IP 25.24 25.48 25.06 25.15 65090 20100330 IP 25.24 25.52 24.9 25.26 42112 20100331 IP 25.11 25.12 24.53 24.61 56030 20100401 IP 24.83 25.29 24.83 25.24 62528 20100405 IP 25.37 25.57 25.2 25.5 58887 20100406 IP 25.28 25.93 25.2 25.91 78716 20100407 IP 26.05 27.33 26.05 27.01 142374 20100408 IP 26.8 27.49 26.48 27.42 78594 20100409 IP 27.42 27.695 27.035 27.47 52407 20100412 IP 27.62 27.62 26.94 27.14 60671 20100413 IP 27.07 27.31 26.8601 27.23 58521 20100414 IP 27.43 28.15 27.43 28.1 53915 20100415 IP 27.93 28.47 27.82 28.1 56791 20100416 IP 27.94 28.58 27.45 27.85 83311 20100419 IP 27.65 27.83 26.912 27.44 58609 20100420 IP 27.71 28.06 27.23 27.42 74143 20100421 IP 27.47 28.43 27.47 28.17 76808 20100422 IP 27.84 28.42 27.57 28.37 41674 20100423 IP 28.41 28.8 28.16 28.63 45850 20100426 IP 28.67 29.25 28.12 28.41 58953 20100427 IP 28.31 28.31 26.905 27.05 64589 20100428 IP 27.17 27.66 26.86 27.18 59656 20100429 IP 27.99 29.14 27.78 28 85452 20100430 IP 28.27 28.45 26.73 26.74 74474 20100503 IP 26.95 27.1301 25.99 26.64 90331 20100504 IP 26.19 26.19 24.81 25.01 111810 20100505 IP 24.6 25.45 24.3 24.76 79523 20100506 IP 24.55 25.16 20.5 23.34 152968 20100507 IP 22.23 23.8 21.53 23.16 151037 20100510 IP 25.01 25.45 24.22 24.79 80144\n\n---\n\n23.36 23.895 23.07 23.64 19368 20100629 CFN 23.35 23.4 22.76 22.85 16452 20100630 CFN 22.78 23 22.66 22.7 16949 20100701 CFN 22.65 22.65 21.93 22.41 22401 20100702 CFN 22.39 22.76 22.2075 22.42 15566 20100706 CFN 22.6 23.29 22.46 22.72 20290 20100707 CFN 23.08 23.15 22.42 22.76 26014 20100708 CFN 22.82 23.1 22.55 22.75 26439 20100709 CFN 22.75 22.75 22.39 22.61 27368 20100712 CFN 22.53 22.62 22.29 22.48 19209 20100713 CFN 22.57 22.9488 22.34 22.86 31311 20100714 CFN 22.8 22.8 22.28 22.56 21951 20100715 CFN 22.5 22.58 22.13 22.42 17123 20100716 CFN 22.26 22.4 21.44 21.55 28220 20100719 CFN 21.59 21.9 21.53 21.83 13903 20100720 CFN 21.67 21.79 21.36 21.66 17946 20100721 CFN 21.68 21.83 20.63 20.68 27314 20100722 CFN 20.89 21.56 20.84 21.19 19021 20100723 CFN 21.09 21.56 21.02 21.56 12887 20100726 CFN 21.48 21.86 21.38 21.85 21351 20100727 CFN 21.92 22.03 21.39 21.52 26421 20100728 CFN 21.45 21.6 21.19 21.31 18182 20100729 CFN 21.37 21.55 20.9 21.1 13138 20100730 CFN 20.94 21.445 20.86 21.07 12556 20100802 CFN 21.35 21.82 21.35 21.43 18314 20100803 CFN 21.48 21.48 21.07 21.14 10389 20100804 CFN 21.17 21.48 21.17 21.45 17342 20100805 CFN 21.32 21.56 21.15 21.49 9523 20100806 CFN 21.32 21.62 21.23 21.49 12990 20100809 CFN 21.63 21.93 21.59 21.72 13733 20100810 CFN 21.58 21.61 20.97 21.4 24851 20100811 CFN 21.91 23.87 21.5 23.26 61782 20100812 CFN 23.04 23.04 22.43 22.75 34432 20100813 CFN 22.64 23.15 22.52 22.85 25298 20100816 CFN 22.73 22.86 22.45 22.59 10549 20100817 CFN 22.79 22.81 22.53 22.53 14979 20100819 CFN 22.37 22.63 21.99 22 16279 20100820 CFN 21.85 22.86 21.53 22.81 24163 20090821 CHK 23.4 23.94 23.29 23.79 106618 20090824 CHK 24 24.36 23.84 23.94 138358 20090825 CHK 24.09 24.23 23.31 23.35 99893 20090826 CHK 23.07 23.45 22.79 23.31 82364 20090827 CHK 23.17 23.22 22.5 23.2 103404 20090828 CHK 23.45 23.6 23.04 23.59 118563 20090831 CHK 23.18 23.25 22.67 22.84 120627 20090901 CHK 22.68 23.42 22.48 22.5 139079 20090902 CHK 22.38 22.7 22.13 22.13 113355 20090903 CHK 22.36 22.49 21.45 21.58 178845 20090904 CHK 21.62 22.27 21.6 22.2 98630 20090909 CHK 23.35 24.15 23.1 23.65 143061 20090910 CHK 23.71 25.41 23.67 25.25 221379 20090911 CHK 25.87 27.1 25.57 26.12 366022 20090914 CHK 25.6 27.16 25.37 27.09 202867 20090915 CHK 27.75 28.5 27.62 28.31 244841 20090916 CHK 28.81 28.99 28.02 28.92 206681 20090917 CHK 28.69 29.2 27.52 27.97 214803 20090918 CHK 28.19 28.35 27.27 27.85 283390 20090921 CHK 27.34 28.19 26.5666 28.11 142238 20090922 CHK 28.57 29.49 28.52 29.11 138463 20090923 CHK 29.16 29.28 28.22 28.3 151353 20090924 CHK 28.35 28.46 27.03 27.82 134923 20090925 CHK 27.61 28.12 27.3 27.53 114799 20090928 CHK 27.55 28.3 27.35 28.17 94562 20090929 CHK 27.92 28.84 27.76 28.59 123885 20090930 CHK 28.8 28.94 27.82 28.4 151594 20091001 CHK 28.31 28.4 26.43 26.5 169100 20091002 CHK 25.74 26.81 25.28 26.7 152501 20091005 CHK 26.94 27.63 26.81 27.5 118176 20091006 CHK 27.48 27.97 27.13 27.74 150919 20091007 CHK 27.65 28.05 27.08 27.59 117706 20091008 CHK 27.97 28.36 27.48 28.28 245382 20091009 CHK 28.18 28.8 28.04 28.66 95692 20091012 CHK 28.77 29.24 28.77 29.01 96061 20091013 CHK 29.25 29.75 28.59 29.46 161349 20091014 CHK 29.98 30 28.29 28.49 259444 20091015 CHK 28.44 29.19 28.32 28.93 151825 20091016 CHK 28.66 29.04 28.51 28.67 138658 20091019 CHK 28.88 29.05 28.62 28.97 80125 20091020 CHK 29.13 29.25 28 28.85 114258 20091021 CHK 28.5 29.68 28.4 28.83 143480 20091022 CHK 28.35 28.6 27.41 27.94 202661 20091023 CHK 28.22 28.33 26.55 26.73 133640 20091026 CHK 26.88 27.59 25.71 25.73 150438 20091027 CHK 25.87 26.86 25.695 26.34 239658 20091028 CHK 26.13 26.13 24.71 24.77 170707 20091105 CHK 24.51 24.94 24.01 24.82 112358 20091106 CHK 24.42 24.95 24.04 24.22 126812 20091109 CHK 24.82 25.35 24.73 25.26 114620 20091110 CHK 25.15 25.42 24.81 25.34 99365 20091111 CHK 25.65 25.81 25.02 25.18 128210 20091112 CHK 25.17 25.69 24.6 24.71 166518 20091113 CHK 24.87 25.2 24.57 25.03 132923 20091116 CHK 25.27 25.61 24.96 25.14 154597 20091117 CHK\n\n---\n\n17.55 17.95 17.37 17.58 57694 20100607 SAI 17.65 17.75 17.4 17.49 35298 20100608 SAI 17.53 17.53 17.28 17.39 44461 20100609 SAI 17.41 17.59 17.34 17.4 35663 20100610 SAI 17.5 17.85 17.5 17.69 45181 20100611 SAI 17.53 17.59 17.34 17.52 46115 20100614 SAI 17.7 17.77 17.51 17.53 54785 20100615 SAI 17.53 17.78 17.53 17.72 36795 20100616 SAI 17.71 18.02 17.65 17.95 42567 20100617 SAI 18 18.09 17.89 18.09 28826 20100618 SAI 18.11 18.2 17.95 17.99 47392 20100621 SAI 18.06 18.18 17.74 17.77 32579 20100622 SAI 17.69 17.78 17.47 17.48 28411 20100623 SAI 17.45 17.48 17.23 17.27 40351 20100624 SAI 17.24 17.43 17.13 17.16 35363 20100625 SAI 17.18 17.3 17.01 17.17 94368 20100628 SAI 17.13 17.27 17.03 17.09 36008 20100629 SAI 17 17.07 16.75 16.82 55804 20100630 SAI 16.9 17.05 16.72 16.74 40656 20100701 SAI 16.7 16.71 16.42 16.55 37781 20100702 SAI 16.59 16.6 16.38 16.43 18416 20100706 SAI 16.66 16.66 16.37 16.5 30794 20100707 SAI 16.44 16.69 16.43 16.68 20026 20100708 SAI 16.72 17.015 16.69 16.83 19202 20100709 SAI 16.81 16.88 16.7 16.85 14679 20100712 SAI 16.82 16.95 16.74 16.89 11999 20100713 SAI 16.99 16.99 16.81 16.92 18321 20100714 SAI 16.78 17.15 16.72 17.05 24410 20100715 SAI 16.99 17.04 16.76 16.9 18710 20100716 SAI 16.8 16.86 16.46 16.46 25825 20100719 SAI 16.41 16.64 16.38 16.54 27075 20100720 SAI 16.46 16.71 16.38 16.69 13313 20100721 SAI 16.72 16.76 16.44 16.47 16321 20100722 SAI 16.57 16.89 16.57 16.83 19505 20100723 SAI 16.78 17.01 16.74 16.98 14067 20100726 SAI 16.97 17 16.86 16.96 13848 20100727 SAI 16.96 17.01 16.79 16.94 16037 20100728 SAI 16.87 16.995 16.78 16.88 17620 20100729 SAI 16.94 16.98 16.62 16.72 15765 20100730 SAI 16.63 16.71 16.574 16.63 16196 20100802 SAI 16.73 16.97 16.6406 16.96 26908 20100803 SAI 16.95 17.09 16.86 17.02 29072 20100804 SAI 17.03 17.1 16.96 17.02 18381 20100805 SAI 16.99 17.2 16.9 17.16 15596 20100806 SAI 17.07 17.14 16.86 16.99 14040 20100809 SAI 17.01 17.06 16.8225 16.95 14942 20100810 SAI 16.81 16.91 16.5 16.59 32295 20100811 SAI 16.48 16.48 15.88 15.93 37773 20100812 SAI 15.64 15.89 15.61 15.87 28716 20100813 SAI 15.87 15.94 15.76 15.78 22608 20100816 SAI 15.71 15.81 15.53 15.54 15625 20100817 SAI 15.55 15.83 15.55 15.77 18613 20100819 SAI 15.6 15.61 15.25 15.52 27961 20100820 SAI 15.43 15.57 15.37 15.55 17602 20090821 SBUX 19.4 19.79 19.24 19.71 94353 20090824 SBUX 19.74 19.85 19.11 19.24 109927 20090825 SBUX 19.24 19.74 19.21 19.5 99323 20090826 SBUX 19.46 19.68 19.21 19.35 83908 20090827 SBUX 19.33 19.56 18.91 19.44 80924 20090828 SBUX 19.64 19.7 19.1575 19.33 66481 20090831 SBUX 19.15 19.28 18.85 18.99 105916 20090901 SBUX 18.94 19.35 18.42 18.56 146692 20090902 SBUX 18.42 18.75 18.38 18.56 85500 20090903 SBUX 18.58 18.69 18.21 18.69 113135 20090904 SBUX 18.72 19.15 18.46 19.02 78565 20090909 SBUX 19.21 20.21 19.13 20.09 206080 20090910 SBUX 20.1 20.24 19.67 19.97 163752 20090911 SBUX 19.93 20.02 19.66 19.89 96381 20090914 SBUX 19.66 20.19 19.58 20.08 92154 20090915 SBUX 20.02 20.16 19.72 19.79 107599 20090916 SBUX 19.84 19.8505 19.55 19.85 99970 20090917 SBUX 19.82 20.48 19.74 20.08 97143 20090918 SBUX 20.5 20.94 20.34 20.76 144985 20090921 SBUX 20.63 20.88 20.34 20.67 90899 20090922 SBUX 20.67 20.77 20.38 20.47 71516 20090923 SBUX 20.39 20.4599 19.66 19.69 118270 20090924 SBUX 19.77 19.92 19.01 19.17 164678 20090925 SBUX 19.21 20.11 19.02 19.83 179400 20090928 SBUX 19.91 20.77 19.88 20.62 129241 20090929 SBUX 20.63 20.76 20.17 20.38 93079 20090930 SBUX 20.36 20.73 19.72 20.65 141584 20091001 SBUX 20.55 20.6 19.8 19.97 118015 20091002 SBUX 19.74 20.0701 19.59 19.74 85075 20091005 SBUX 19.76 20.14 19.6 20.06 72789 20091006 SBUX 20.01 20.73 19.95 20.53 108923 20091007 SBUX 20.44 20.6 20.18 20.4 69970 20091008 SBUX 20.46 20.99 20.37 20.47 104376 20091009 SBUX 20.33 20.62 20.1 20.24 88916 20091012 SBUX 20.15 20.54 20.08 20.36 100194 20091013 SBUX 20.42 20.43 20.03 20.19 67601 20091014 SBUX 20.39 20.72 20.32 20.54 74390 20091015 SBUX 20.33 20.725 20.29 20.72 101432 20091016 SBUX 20.64\n\n---\n\nAEE 25.7 25.78 25.12 25.2 11525 20091026 AEE 25.27 25.59 24.88 25.01 26321 20091027 AEE 25.02 25.41 25 25.03 16176 20091028 AEE 24.97 25.23 24.72 24.99 19218 20091105 AEE 24.28 24.77 24.24 24.75 14314 20091106 AEE 24.68 24.9 24.54 24.68 13450 20091109 AEE 24.86 25.39 24.76 25.38 16218 20091110 AEE 25.31 25.58 25.31 25.53 18363 20091111 AEE 25.66 25.73 25.46 25.63 15535 20091112 AEE 25.54 25.65 25.29 25.4 13742 20091113 AEE 25.41 25.83 25.41 25.72 12993 20091116 AEE 25.76 25.99 25.66 25.79 20642 20091117 AEE 25.78 26.02 25.76 25.89 10856 20091118 AEE 25.85 25.94 25.7 25.88 10998 20091119 AEE 25.76 25.8 25.24 25.35 18888 20091120 AEE 25.27 25.36 25.1 25.28 21149 20091123 AEE 25.35 25.72 25.35 25.6 12373 20091124 AEE 25.68 25.77 25.4 25.77 15460 20091125 AEE 25.82 26.06 25.71 26 14560 20091127 AEE 25.59 25.78 25.3685 25.58 7625 20091130 AEE 25.54 26 25.47 25.99 24024 20091201 AEE 26.14 26.59 26.05 26.58 24827 20091202 AEE 26.63 26.97 26.51 26.89 24685 20091203 AEE 26.98 27.38 26.9 27.09 17479 20091204 AEE 27.35 27.64 26.75 27.01 37033 20091207 AEE 26.7 27.05 26.67 26.94 32543 20091208 AEE 26.93 26.94 26.63 26.72 18245 20091209 AEE 26.72 26.84 26.57 26.78 11218 20091210 AEE 26.88 27.22 26.8 26.98 14770 20091211 AEE 26.98 27.86 26.932 27.82 21946 20091214 AEE 27.88 28.37 27.88 28.16 17835 20091215 AEE 28.03 28.24 27.92 28.1 12638 20091216 AEE 28.13 28.2 27.69 27.75 17922 20091217 AEE 27.65 27.88 27.46 27.76 14179 20091218 AEE 27.85 28.045 27.54 28 18695 20091221 AEE 28.04 28.47 28.03 28.12 12074 20091222 AEE 28.2 28.3 27.92 28 12640 20091223 AEE 28.04 28.25 27.99 28.22 9112 20091224 AEE 28.19 28.54 28.19 28.53 3107 20091228 AEE 28.52 28.67 28.43 28.59 8059 20091229 AEE 28.55 28.63 28.45 28.45 6431 20091230 AEE 28.32 28.48 28.21 28.41 7453 20091231 AEE 28.56 28.64 27.95 27.95 8125 20100104 AEE 28.1 28.27 27.69 27.76 12992 20100105 AEE 27.76 27.84 27.41 27.65 14221 20100106 AEE 27.61 27.89 27.35 27.46 18802 20100107 AEE 27.47 27.47 27.05 27.2 9368 20100108 AEE 27.22 27.22 26.83 27.01 9540 20100111 AEE 27.05 27.28 27.05 27.23 9978 20100112 AEE 27.15 27.455 27.09 27.2 10218 20100113 AEE 27.2 27.49 27.14 27.38 12408 20100114 AEE 27.26 27.5 27.25 27.48 7630 20100115 AEE 27.41 27.48 26.92 27.34 17760 20100119 AEE 27.37 27.74 27.27 27.69 12729 20100120 AEE 27.5 27.54 27.03 27.17 16385 20100121 AEE 27.21 27.4 26.22 26.52 40651 20100122 AEE 26.58 26.58 25.75 25.78 25699 20100125 AEE 26.01 26.065 25.76 25.91 15819 20100126 AEE 25.86 26.08 25.73 25.98 15250 20100127 AEE 25.98 26.05 25.6 25.99 19436 20100128 AEE 25.88 26.03 25.5 25.73 18879 20100129 AEE 25.86 25.93 25.51 25.55 15829 20100201 AEE 25.59 25.75 25.32 25.49 17151 20100202 AEE 25.48 25.78 25.25 25.77 19811 20100203 AEE 25.32 25.65 25.29 25.61 21624 20100204 AEE 25.45 25.46 24.98 24.98 16528 20100205 AEE 25 25.03 24.45 24.86 28363 20100208 AEE 24.88 24.99 24.42 24.42 18577 20100209 AEE 24.62 24.99 24.51 24.63 19161 20100210 AEE 24.66 24.66 24.29 24.41 20904 20100211 AEE 24.41 24.71 24.14 24.63 26048 20100212 AEE 24.46 24.63 24.25 24.56 19867 20100216 AEE 24.76 25.15 24.71 25.09 14547 20100217 AEE 25.22 25.4 25.06 25.4 19574 20100218 AEE 25.47 26.25 25.47 25.64 31384 20100219 AEE 25.62 26.055 25.35 25.65 20659 20100222 AEE 25.8 25.82 25.36 25.41 13968 20100223 AEE 25.4 25.4699 25.17 25.29 14028 20100224 AEE 25.34 25.45 24.89 25.14 16401 20100225 AEE 24.91 25.07 24.66 25.07 18760 20100226 AEE 25.12 25.12 24.65 24.71 21390 20100301 AEE 24.82 25.14 24.82 25.04 13755 20100302 AEE 25.17 25.36 25.13 25.33 12530 20100303 AEE 25.34 25.53 25.28 25.43 15807 20100304 AEE 25.42 25.6 25.3 25.59 16039 20100305 AEE 25.74 25.94 25.6 25.94 20167 20100308 AEE 25.44 25.53 25.31 25.5 19572 20100309 AEE 25.44 25.61 25.37 25.57 13655 20100310 AEE 25.58 25.78 25.45 25.57 16012 20100311 AEE 25.56 25.76 25.36 25.76 12690 20100312 AEE 25.82 25.89 25.5 25.51 11751 20100315 AEE 25.49 25.5999 25.35 25.49 16995 20100316 AEE 25.49 25.58 25.4 25.5 14483 20100317 AEE 25.5 25.7 25.43 25.67 10146 20100318 AEE 25.69 26\n\n---\n\n24.85 291030 20091002 FIS 24.55 24.74 23.96 23.99 57072 20091005 FIS 24.07 24.37 23.89 23.91 55853 20091006 FIS 24.01 24.49 23.93 24.28 45289 20091007 FIS 24.23 24.48 23.93 24.13 37881 20091008 FIS 24.36 24.48 24.12 24.3 28166 20091009 FIS 24.21 24.41 24.055 24.35 23512 20091012 FIS 24.19 24.47 24.13 24.3 20012 20091013 FIS 24.21 24.37 23.99 24.14 26352 20091014 FIS 24.24 24.46 24.22 24.44 21448 20091015 FIS 24.28 24.56 24.22 24.53 20971 20091016 FIS 24.38 24.98 24.14 24.43 31087 20091019 FIS 24.46 24.82 24.44 24.6 24752 20091020 FIS 24.55 24.55 24.27 24.51 20685 20091021 FIS 24.38 25.12 24.33 24.83 50850 20091022 FIS 22.92 23.95 22.38 23.64 116624 20091023 FIS 23.79 23.79 22.69 22.82 35424 20091026 FIS 22.8 22.94 22.44 22.61 36035 20091027 FIS 22.63 22.76 22.47 22.58 33560 20091028 FIS 22.46 22.46 21.75 21.78 43643 20091105 FIS 22.12 22.55 21.95 22.55 27787 20091106 FIS 22.53 22.66 22.14 22.46 29781 20091109 FIS 22.5 22.95 22.39 22.94 26490 20091110 FIS 22.82 22.94 22.65 22.9 25483 20091111 FIS 23.03 23.07 22.7 22.94 21141 20091112 FIS 22.9 23 22.61 22.66 23388 20091113 FIS 22.59 22.8 22.38 22.59 20263 20091116 FIS 22.58 22.77 22.51 22.63 38179 20091117 FIS 22.65 22.81 22.35 22.58 28466 20091118 FIS 23.39 23.9 22.99 23.47 46192 20091119 FIS 23.27 23.5 22.91 23.11 35826 20091120 FIS 22.85 23 22.64 22.73 29178 20091123 FIS 23.06 23.065 22.74 22.97 27407 20091124 FIS 23.04 23.04 22.69 22.77 21316 20091125 FIS 23 23.2 22.9 22.98 46120 20091127 FIS 22.53 22.71 22.4 22.53 14833 20091130 FIS 22.46 22.65 22.34 22.6 25390 20091201 FIS 22.73 23.48 22.69 23.42 32213 20091202 FIS 23.23 23.59 23.2 23.32 22563 20091203 FIS 23.34 23.5 23.01 23.17 22167 20091204 FIS 23.38 23.6 23.03 23.46 25041 20091207 FIS 23.31 23.73 23.11 23.48 46789 20091208 FIS 23.37 23.42 23.05 23.17 34865 20091209 FIS 23.03 23.4 22.87 23.32 30689 20091210 FIS 23.45 23.74 23.37 23.67 25488 20091211 FIS 23.72 23.77 23.57 23.73 20987 20091214 FIS 23.77 23.96 23.7 23.96 22964 20091215 FIS 23.76 23.88 23.66 23.76 31986 20091216 FIS 23.83 23.895 23.38 23.52 29442 20091217 FIS 23.42 23.48 23.16 23.17 18009 20091218 FIS 23.47 24.05 23.31 23.53 27895 20091221 FIS 23.49 23.7 23.25 23.3 23012 20091222 FIS 23.35 23.65 23.32 23.59 14014 20091223 FIS 23.55 23.79 23.52 23.75 11607 20091224 FIS 23.79 24 23.75 23.98 4714 20091228 FIS 23.93 23.96 23.69 23.72 15667 20091229 FIS 23.75 23.94 23.63 23.63 8039 20091230 FIS 23.62 23.76 23.49 23.61 18191 20091231 FIS 23.7 23.7 23.44 23.44 9634 20100104 FIS 23.63 23.96 23.44 23.82 46236 20100105 FIS 23.99 24.88 23.93 24.84 48687 20100106 FIS 24.81 24.93 24.54 24.7 24811 20100107 FIS 24.69 24.69 24.41 24.56 33848 20100108 FIS 24 24.3 23.86 24.05 24599 20100111 FIS 24.2 24.25 23.74 23.93 30100 20100112 FIS 23.8 23.87 23.65 23.85 20386 20100113 FIS 23.53 24.345 23.53 24.25 34669 20100114 FIS 24.24 24.4 24.09 24.35 11709 20100115 FIS 24.34 24.4 23.9 23.99 20619 20100119 FIS 23.88 24.43 23.86 24.41 18183 20100120 FIS 24.21 24.45 23.92 24.25 21683 20100121 FIS 24.25 24.94 24.1 24.34 49646 20100122 FIS 24.23 24.48 23.95 23.96 38003 20100125 FIS 24.15 24.385 23.95 24.07 33978 20100126 FIS 24.02 24.24 23.95 24.01 21739 20100127 FIS 24.01 24.23 23.87 24.22 24548 20100128 FIS 24.21 24.22 23.63 23.75 38237 20100129 FIS 23.83 23.96 23.52 23.56 27140 20100201 FIS 23.85 23.85 23.48 23.76 23252 20100202 FIS 23.79 23.95 23.56 23.95 23251 20100203 FIS 23.83 24.01 23.62 23.99 25181 20100204 FIS 24.01 24.15 23.52 23.54 42529 20100205 FIS 23.62 23.62 22.74 23.04 47769 20100208 FIS 23 23.12 22.8 22.92 28764 20100209 FIS 23.17 23.44 22.74 22.78 45553 20100210 FIS 22.73 22.78 22.27 22.28 53012 20100211 FIS 22.28 22.52 22.25 22.47 38774 20100212 FIS 22.3 22.5 22.13 22.36 41519 20100216 FIS 22.48 22.64 22.36 22.52 19539 20100217 FIS 22.61 22.61 22.32 22.61 28800 20100218 FIS 22.56 22.78 22.41 22.61 37029 20100219 FIS 22.48 22.79 22.42 22.68 28900 20100222 FIS 22.71 22.84 22.6 22.65 18346 20100223 FIS 22.65 22.81 22.45 22.6 26523 20100224 FIS 22.68 22.92 22.445 22.88\n\n---\n\n13.24 141302 20100802 DELL 13.43 13.68 13.35 13.61 104059 20100803 DELL 13.55 13.6 13.34 13.42 91235 20100804 DELL 13.48 13.53 13.07 13.21 203854 20100805 DELL 13.08 13.22 12.87 13.13 253347 20100806 DELL 13 13.12 12.87 13.12 162920 20100809 DELL 13.23 13.24 12.91 12.98 179507 20100810 DELL 12.77 12.81 12.37 12.45 373440 20100811 DELL 12.24 12.27 11.84 12.1 298803 20100812 DELL 11.8 12.12 11.76 11.99 208530 20100813 DELL 12.03 12.18 11.99 12.01 176413 20100816 DELL 11.9 12.0801 11.8 11.96 131415 20100819 DELL 12.09 12.18 11.97 12.04 300258 20100820 DELL 11.84 12.24 11.8 12.07 502579 20090821 DF 18.35 18.35 17.91 18.11 28269 20090824 DF 18.17 18.25 17.66 17.92 19673 20090825 DF 18 18.15 17.78 17.99 17852 20090826 DF 18 18.33 17.81 18.23 24255 20090827 DF 18.16 18.31 18.05 18.27 13047 20090828 DF 18.31 18.31 18.01 18.18 17527 20090831 DF 18.06 18.27 17.9 18.14 18156 20090901 DF 18.13 18.17 17.57 17.6 29563 20090902 DF 17.48 17.8 17.45 17.73 24926 20090903 DF 17.85 18.36 17.63 18.32 29932 20090904 DF 18.36 18.47 18.15 18.19 19262 20090909 DF 18.12 18.28 17.9 18.08 20513 20090910 DF 18.1 18.23 18 18.09 21150 20090911 DF 18.15 18.25 17.98 18.12 14457 20090914 DF 18.03 18.41 18.01 18.27 18133 20090915 DF 18.28 18.3 18.1 18.25 22024 20090916 DF 18.24 18.4 18.02 18.25 13368 20090917 DF 18.25 18.4 18.02 18.03 18252 20090918 DF 18.05 18.47 18.05 18.4 24422 20090921 DF 18.27 18.39 18.2 18.32 16549 20090922 DF 18.36 18.36 18.05 18.08 16453 20090923 DF 18.1 18.4 17.94 18.2 30254 20090924 DF 18.23 18.36 17.9 18 21350 20090925 DF 17.95 18.07 17.78 17.84 18462 20090928 DF 17.84 18.09 17.84 17.96 8102 20090929 DF 17.98 18.02 17.695 17.78 18967 20090930 DF 17.77 17.84 17.45 17.79 23502 20091001 DF 17.78 18.22 17.58 18.15 42561 20091002 DF 18.05 18.875 17.97 18.77 58295 20091005 DF 18.83 18.96 18.59 18.89 33102 20091006 DF 18.97 19.12 18.56 18.61 41803 20091007 DF 18.48 18.68 18.47 18.65 33162 20091008 DF 18.72 19.18 18.71 19.16 23017 20091009 DF 19.1 19.44 19 19.27 34421 20091012 DF 19.24 19.43 19.1 19.24 19142 20091013 DF 19.16 19.3 18.91 19.13 39026 20091014 DF 19.11 19.29 19.09 19.23 30246 20091015 DF 19.25 19.5 19.055 19.43 23836 20091016 DF 19.36 19.75 19.251 19.64 25898 20091019 DF 19.69 19.76 19.55 19.65 21840 20091020 DF 19.44 19.495 18.97 19.03 26519 20091021 DF 19.05 19.26 18.74 18.74 27524 20091022 DF 18.76 18.84 18.52 18.77 16855 20091023 DF 18.75 18.77 18.19 18.26 19981 20091026 DF 18.26 18.7 18.23 18.33 28651 20091027 DF 18.41 18.4899 18.07 18.07 26389 20091028 DF 18.14 18.23 17.84 17.84 27831 20091105 DF 16.96 17.14 16.82 17.01 29876 20091106 DF 16.87 17.08 16.68 16.78 27193 20091109 DF 17 17 16.81 16.89 30305 20091110 DF 16.8 17.02 16.69 16.81 21091 20091111 DF 16.94 16.95 16.61 16.76 30867 20091112 DF 16.73 16.8 16.41 16.44 32167 20091113 DF 16.42 16.46 16.14 16.28 31961 20091116 DF 16.42 16.49 16.2 16.3 30319 20091117 DF 16.29 16.37 15.97 16.04 34347 20091118 DF 16.13 16.33 15.95 15.96 56118 20091119 DF 15.97 16.04 15.75 15.94 43546 20091120 DF 15.88 16.22 15.77 16.12 33306 20091123 DF 16.26 16.34 16.15 16.29 31231 20091124 DF 16.37 16.47 16.14 16.29 37691 20091125 DF 16.35 16.4 16.11 16.19 19152 20091127 DF 15.9 16.14 15.77 16.07 11074 20091130 DF 16.15 16.17 15.74 15.9 27355 20091201 DF 16.08 16.26 15.93 16.21 30320 20091202 DF 16.24 16.44 16.11 16.38 22430 20091203 DF 16.45 16.52 16.31 16.35 21590 20091204 DF 16.43 16.8 16.41 16.8 41831 20091207 DF 16.82 17 16.74 16.82 31588 20091208 DF 16.88 17.14 16.69 17.06 35313 20091209 DF 17.1 17.17 16.89 17.15 27013 20091210 DF 17.24 17.24 16.91 16.98 24269 20091211 DF 17.02 17.43 17.02 17.25 22856 20091214 DF 17.31 17.58 17.12 17.26 17543 20091215 DF 17.14 17.42 17.1 17.29 22973 20091216 DF 17.33 17.54 17.18 17.23 19187 20091217 DF 17.1 17.19 16.86 17.11 22721 20091218 DF 17.13 17.33 17.125 17.31 22737 20091221 DF 17.33 17.8 17.33 17.68 19475 20091222 DF 17.53 18 17.53 17.99 24927 20091223 DF 17.98 18.54 17.98 18.43 25260 20091224 DF 18.37 18.48 18.24 18.27 6472 20091228 DF 18.25\n\n---\n\n7.12 10638 20090903 NYT 7.14 7.26 6.94 7.14 6390 20090904 NYT 7.13 7.21 6.86 7.14 7618 20090909 NYT 7.23 7.39 7.14 7.37 6876 20090910 NYT 7.37 7.81 7.26 7.72 14066 20090911 NYT 7.74 7.94 7.67 7.78 14374 20090914 NYT 7.68 7.78 7.46 7.73 7965 20090915 NYT 7.7 7.91 7.57 7.88 10038 20090916 NYT 8 8.86 7.9 8.82 23639 20090917 NYT 8.78 9.34 8.3501 8.42 23484 20090918 NYT 8.57 8.57 8.2505 8.36 24884 20090921 NYT 8.25 8.3 7.85 8.16 12911 20090922 NYT 8.23 8.6801 8.16 8.37 19439 20090923 NYT 8.41 8.55 8.08 8.12 16989 20090924 NYT 8.16 8.19 7.69 7.75 12706 20090925 NYT 7.74 7.985 7.47 7.78 10106 20090928 NYT 7.74 8.08 7.67 7.99 10531 20090929 NYT 8.7 8.86 8.26 8.39 42478 20090930 NYT 8.35 8.47 8 8.12 24738 20091001 NYT 8.08 8.14 7.6 7.75 14317 20091002 NYT 7.64 7.67 7.25 7.32 13087 20091005 NYT 7.33 7.85 7.28 7.81 15536 20091006 NYT 7.9 8.39 7.74 8.2 21294 20091007 NYT 8.19 8.22 7.92 8.03 17398 20091008 NYT 8.11 8.62 8.06 8.59 17466 20091009 NYT 8.57 8.65 8.36 8.48 8154 20091012 NYT 8.48 8.65 8.29 8.39 7292 20091013 NYT 8.34 8.39 8.09 8.31 7336 20091014 NYT 8.51 8.7 8.14 8.67 13422 20091015 NYT 8.44 8.92 8.35 8.67 21474 20091016 NYT 8.57 8.72 8.37 8.48 9449 20091019 NYT 8.52 8.93 8.23 8.91 15153 20091020 NYT 9.07 9.07 8.63 8.65 12572 20091021 NYT 8.65 9.08 8.49 8.75 19988 20091022 NYT 9.75 10.84 9.51 10.72 65884 20091023 NYT 10.65 11.05 10.41 10.74 34202 20091026 NYT 10.86 10.93 9.94 10.08 26626 20091027 NYT 10.06 10.25 9.62 9.71 19278 20091028 NYT 9.57 9.62 8.51 8.56 45601 20091105 NYT 7.71 8.28 7.71 8.26 23206 20091106 NYT 7.97 8.41 7.97 8.17 19497 20091109 NYT 8.21 8.705 8.14 8.63 20685 20091110 NYT 8.59 8.81 8.47 8.67 17144 20091111 NYT 8.81 9.15 8.81 8.99 21574 20091112 NYT 8.94 9.2 8.86 8.91 16559 20091113 NYT 8.97 9.17 8.82 8.95 17358 20091116 NYT 9.08 9.6222 8.97 9.55 15899 20091117 NYT 9.5 9.58 9.235 9.55 9973 20091118 NYT 9.46 9.515 9.16 9.25 14866 20091119 NYT 9.16 9.17 8.69 8.84 14683 20091120 NYT 8.86 8.86 8.36 8.65 10192 20091123 NYT 8.97 9.1 8.84 8.91 12416 20091124 NYT 8.89 9.15 8.73 8.88 8667 20091125 NYT 8.92 9.04 8.8897 8.99 8287 20091127 NYT 8.49 8.87 8.32 8.76 6218 20091130 NYT 8.7 8.78 8.34 8.44 17322 20091201 NYT 8.68 8.8 8.48 8.6 10600 20091202 NYT 8.6 8.78 8.39 8.52 8992 20091203 NYT 8.61 8.8 8.55 8.55 12283 20091204 NYT 8.65 8.9 8.34 8.72 16419 20091207 NYT 8.61 9.03 8.61 8.9 30424 20091208 NYT 8.9 9.29 8.62 9.01 26967 20091209 NYT 8.98 9.02 8.7301 8.96 26400 20091210 NYT 8.89 9.32 8.88 9.08 44478 20091211 NYT 9.18 9.24 8.98 9.19 17117 20091214 NYT 9.34 9.75 9.2 9.69 21008 20091215 NYT 9.67 10.12 9.515 10.1 25842 20091216 NYT 10.02 10.75 10.02 10.68 38970 20091217 NYT 10.59 10.59 10.23 10.25 18358 20091218 NYT 10.56 11.11 10.1 10.4 40894 20091221 NYT 10.68 10.84 10.3805 10.79 34244 20091222 NYT 10.97 11.18 10.7 11.03 26988 20091223 NYT 11.99 12.11 11.46 12.1 46480 20091224 NYT 12.09 12.46 12.09 12.16 10373 20091228 NYT 12.21 12.255 12.11 12.22 14701 20091229 NYT 12.31 12.41 12 12.13 15155 20091230 NYT 12.095 12.75 12.05 12.63 27141 20091231 NYT 12.63 12.6492 12.34 12.36 21647 20100104 NYT 12.65 13.19 12.49 13.03 25360 20100105 NYT 13.04 13.87 13 13.46 43969 20100106 NYT 13.47 13.9301 13.37 13.76 25803 20100107 NYT 13.64 14.22 13.58 14.2 22539 20100108 NYT 14.09 14.191 13.75 14.11 18034 20100111 NYT 14.12 14.87 14.05 14.67 29469 20100112 NYT 14.48 14.69 13.59 13.86 30774 20100113 NYT 13.98 14.06 13.47 13.9 24796 20100114 NYT 13.77 14.1 13.6 13.95 17534 20100115 NYT 13.89 13.98 13.04 13.33 25775 20100119 NYT 13.34 13.72 13.23 13.7 20288 20100120 NYT 13.43 13.69 13.05 13.31 29100 20100121 NYT 13.3 13.64 12.7 12.71 30263 20100122 NYT 12.6 13.17 12.43 12.45 21357 20100125 NYT 12.7 12.7 12.12 12.51 19892 20100126 NYT 12.38 13.24 12.38 13.02 27401 20100127 NYT 13.26 13.94 12.94 13.23 29590 20100128 NYT 13.27 13.4 12.66 13.01 14562 20100129 NYT 13.06 13.47 12.85 12.92 22890 20100201 NYT 12.84 12.93 12.15 12.49 27050 20100202 NYT 12.6 12.82 12.34 12.69 15613 20100203 NYT 12.66 13.37 12.46 12.49 23979 20100204 NYT 12.3\n\n---\n\n24.76 137482 20090915 TXN 24.89 25 24.64 24.83 119897 20090916 TXN 24.88 24.88 24 24.13 162048 20090917 TXN 24.1 24.2 23.6 23.6 194796 20090918 TXN 23.79 24.21 23.62 24.06 181645 20090921 TXN 23.96 24.23 23.81 23.97 112035 20090922 TXN 24.2 24.2 23.57 23.76 161261 20090923 TXN 23.89 24.55 23.86 24.05 168747 20090924 TXN 24.08 24.15 23.46 23.57 136109 20090925 TXN 23.42 23.76 23.152 23.35 135947 20090928 TXN 23.5 24.18 23.42 23.91 114289 20090929 TXN 23.96 24.37 23.515 23.55 153270 20090930 TXN 23.67 24.12 23.47 23.69 186468 20091001 TXN 23.52 23.74 22.6 22.65 221998 20091002 TXN 22.45 22.77 22.26 22.49 204233 20091005 TXN 22.59 22.93 22.49 22.6 185287 20091006 TXN 22.85 23.24 22.79 23.1 169763 20091007 TXN 22.99 23.11 22.67 22.82 140129 20091008 TXN 22.93 22.93 22.26 22.53 218869 20091009 TXN 22.48 23.65 22.48 23.64 206518 20091012 TXN 23.71 24.31 23.59 23.8 179585 20091013 TXN 23.91 24.02 23.46 23.62 149151 20091014 TXN 24.02 24.07 23.35 23.62 225334 20091015 TXN 23.39 23.46 23.13 23.25 166642 20091016 TXN 23.12 23.12 22.54 22.75 239165 20091019 TXN 23 23.55 22.89 23.52 360348 20091020 TXN 24.11 24.11 23.51 23.66 304120 20091021 TXN 23.64 23.78 22.85 23 277262 20091022 TXN 22.87 23.92 22.87 23.88 325954 20091023 TXN 24 24 23.38 23.5 235982 20091026 TXN 23.38 23.96 23.3075 23.7 197530 20091027 TXN 24.03 24.35 23.69 23.8 293375 20091028 TXN 23.93 24.56 23.41 23.44 289378 20091105 TXN 23.8 24.31 23.65 24.18 131489 20091106 TXN 24.06 24.48 23.93 24.04 117565 20091109 TXN 24.15 24.71 24.03 24.63 106136 20091110 TXN 24.6 25.27 24.58 25.05 194136 20091111 TXN 25.15 25.69 25.13 25.33 146860 20091112 TXN 25.26 25.85 25.19 25.37 133259 20091113 TXN 25.44 25.68 25.24 25.44 103365 20091116 TXN 25.57 26.08 25.52 25.95 123840 20091117 TXN 25.82 25.97 25.57 25.87 109403 20091118 TXN 25.83 25.94 25.4775 25.75 107571 20091119 TXN 24.8 24.96 24.45 24.88 196354 20091120 TXN 24.75 25 24.65 24.74 132528 20091123 TXN 24.93 25.39 24.89 25.14 90201 20091124 TXN 25.18 25.54 25.14 25.28 112915 20091125 TXN 25.34 25.45 25.18 25.42 82818 20091127 TXN 24.8 25.4 24.56 25.25 72784 20091130 TXN 25.35 25.39 25.03 25.29 124688 20091201 TXN 25.55 26.03 25.29 25.94 158424 20091202 TXN 26.01 26.33 25.72 25.96 206741 20091203 TXN 26.06 26.68 26 26.44 144666 20091204 TXN 26.74 27 26.34 26.85 163391 20091207 TXN 26.71 27 26.43 26.62 126258 20091208 TXN 26.72 26.9 25.12 26.33 182153 20091209 TXN 25.76 25.99 25.51 25.99 227332 20091210 TXN 26.08 26.19 25.54 25.94 201188 20091211 TXN 25.9 26.06 25.5 25.64 98964 20091214 TXN 25.76 26.07 25.695 25.98 84834 20091215 TXN 25.88 25.89 25.4 25.44 113230 20091216 TXN 25.57 26.08 25.44 25.58 143289 20091217 TXN 25.33 25.6 25.06 25.08 107356 20091218 TXN 25.36 25.54 25.06 25.46 135455 20091221 TXN 25.71 25.99 25.52 25.84 77296 20091222 TXN 25.87 26.01 25.56 25.64 72096 20091223 TXN 25.44 25.62 25.27 25.32 82274 20091224 TXN 25.36 25.85 25.32 25.83 39777 20091228 TXN 25.78 25.84 25.34 25.49 87818 20091229 TXN 25.51 25.59 25.28 25.37 60886 20091230 TXN 25.42 25.98 25.31 25.98 71803 20091231 TXN 25.95 26.27 25.94 26.06 84327 20100104 TXN 26.2 26.61 25.89 26.01 103693 20100105 TXN 25.95 26.3 25.7 25.86 109437 20100106 TXN 25.9 26.03 25.56 25.67 89338 20100107 TXN 25.6 25.84 25.36 25.75 107755 20100108 TXN 25.6 26.34 25.52 26.34 128756 20100111 TXN 26.21 26.49 25.72 26 116786 20100112 TXN 26.02 26.03 24.67 24.91 211653 20100113 TXN 25.01 25.16 24.67 25.02 188092 20100114 TXN 24.89 25 24.48 24.71 229143 20100115 TXN 24.68 24.77 24.2 24.5 203598 20100119 TXN 24.45 24.78 24.35 24.72 117859 20100120 TXN 24.52 24.61 24.2 24.55 132536 20100121 TXN 24.55 24.88 24.01 24.18 184079 20100122 TXN 24.1 24.17 23 23.11 218077 20100125 TXN 23.41 23.82 23.2 23.69 201920 20100126 TXN 23.39 23.9 23.29 23.35 196508 20100127 TXN 23.37 23.66 23.08 23.53 195358 20100128 TXN 23.46 23.51 22.69 23.05 202002 20100129 TXN 23.11 23.37 22.28 22.5 231372 20100201 TXN 22.56 23.08 22.56 23.05 131989 20100202 TXN 22.97 23.37 22.94 23.31 118910 20100203 TXN 23.26\n\n---\n\nIPG 7.24 7.37 7.04 7.36 89323 20090917 IPG 7.32 7.39 7.12 7.28 66142 20090918 IPG 7.35 7.56 7.35 7.47 60774 20090921 IPG 7.4 7.49 7.13 7.4 62907 20090922 IPG 7.18 7.45 7.16 7.2 51463 20090923 IPG 7.23 7.49 7.21 7.26 71708 20090924 IPG 7.29 7.32 6.9 7.04 69009 20090925 IPG 7.01 7.19 6.95 7.02 39633 20090928 IPG 6.99 7.32 6.98 7.3 30317 20090929 IPG 7.4 7.63 7.35 7.59 82616 20090930 IPG 7.6 7.77 7.45 7.52 117214 20091001 IPG 7.45 7.5 7.03 7.06 63095 20091002 IPG 6.95 7.06 6.79 6.84 83682 20091005 IPG 6.82 7.03 6.75 6.92 62810 20091006 IPG 6.95 7.21 6.92 7.11 52387 20091007 IPG 7.14 7.15 6.8 6.88 67688 20091008 IPG 6.94 7.13 6.9 7.09 67312 20091009 IPG 7.1 7.15 7 7.07 31903 20091012 IPG 7.09 7.19 6.93 6.96 32964 20091013 IPG 6.98 7.11 6.94 7.04 37116 20091014 IPG 7.14 7.15 6.91 7.01 97043 20091015 IPG 6.97 7.22 6.64 6.87 63644 20091016 IPG 6.78 6.85 6.47 6.79 102166 20091019 IPG 6.82 6.82 6.67 6.72 76828 20091020 IPG 6.72 6.8 6.44 6.49 94219 20091021 IPG 6.41 6.54 6.17 6.17 115282 20091022 IPG 6.2 6.37 6.13 6.34 70891 20091023 IPG 6.39 6.41 6.07 6.12 62433 20091026 IPG 6.14 6.31 6.02 6.06 84866 20091027 IPG 6.05 6.2 5.92 6.11 96031 20091028 IPG 6.24 6.47 5.89 5.96 177283 20091105 IPG 6.21 6.4 6.17 6.38 57918 20091106 IPG 6.36 6.56 6.31 6.47 56087 20091109 IPG 6.52 6.79 6.47 6.77 55186 20091110 IPG 6.75 6.815 6.61 6.7 39994 20091111 IPG 6.79 6.91 6.73 6.87 49326 20091112 IPG 6.87 6.97 6.57 6.59 67202 20091113 IPG 6.63 6.85 6.56 6.77 43970 20091116 IPG 6.78 7.06 6.78 7.02 37393 20091117 IPG 6.93 7.05 6.78 6.86 39452 20091118 IPG 6.86 6.89 6.69 6.87 26369 20091119 IPG 6.81 6.84 6.64 6.77 43272 20091120 IPG 6.71 6.89 6.63 6.83 42567 20091123 IPG 6.84 7.01 6.68 6.74 35855 20091124 IPG 6.5 6.74 6.32 6.55 54565 20091125 IPG 6.53 6.63 6.49 6.61 30862 20091127 IPG 6.38 6.52 6.09 6.46 15082 20091130 IPG 6.45 6.5 6.21 6.33 39586 20091201 IPG 6.38 6.51 6.33 6.47 38496 20091202 IPG 6.42 6.62 6.42 6.49 36654 20091203 IPG 6.49 6.55 6.39 6.42 27907 20091204 IPG 6.43 6.55 6.21 6.36 73351 20091207 IPG 6.36 6.63 6.31 6.55 56968 20091208 IPG 6.6 6.91 6.47 6.9 86326 20091209 IPG 6.92 7.03 6.8 6.93 82481 20091210 IPG 7.05 7.29 6.95 7.18 93080 20091211 IPG 7.24 7.28 7.11 7.24 38193 20091214 IPG 7.24 7.57 7.2 7.53 60945 20091215 IPG 7.4 7.51 7.36 7.46 59149 20091216 IPG 7.52 7.55 7.32 7.4 51605 20091217 IPG 7.24 7.4 7.14 7.14 39066 20091218 IPG 7.15 7.23 7.14 7.17 79754 20091221 IPG 7.29 7.29 7.08 7.17 41917 20091222 IPG 7.16 7.22 7.1099 7.18 40949 20091223 IPG 7.16 7.26 7.11 7.22 33797 20091224 IPG 7.28 7.41 7.21 7.4 17566 20091228 IPG 7.49 7.49 7.15 7.25 24456 20091229 IPG 7.28 7.3095 7.175 7.2 21556 20091230 IPG 7.15 7.29 7.13 7.28 23348 20091231 IPG 7.46 7.62 7.33 7.38 42574 20100104 IPG 7.45 7.62 7.4 7.53 44442 20100105 IPG 7.54 7.54 7.41 7.45 61346 20100106 IPG 7.4 7.46 7.32 7.45 55860 20100107 IPG 7.37 7.45 7.19 7.26 62023 20100108 IPG 7.27 7.3 7.08 7.27 64807 20100111 IPG 7.25 7.47 7.22 7.47 52904 20100112 IPG 7.41 7.41 7.23 7.29 46306 20100113 IPG 7.31 7.45 7.19 7.38 35044 20100114 IPG 7.4 7.46 7.14 7.22 115065 20100115 IPG 7.17 7.24 6.98 7.16 87290 20100119 IPG 7.18 7.21 7.07 7.12 36478 20100120 IPG 7.03 7.16 6.95 7.15 50447 20100121 IPG 7.24 7.33 6.98 7.01 61345 20100122 IPG 6.99 7.02 6.81 6.85 56339 20100125 IPG 6.94 6.94 6.76 6.78 36300 20100126 IPG 6.73 6.82 6.6299 6.66 47012 20100127 IPG 6.61 6.63 6.38 6.47 98689 20100128 IPG 6.5 6.665 6.455 6.52 58320 20100129 IPG 6.58 6.61 6.41 6.46 67687 20100201 IPG 6.52 6.65 6.47 6.6 71305 20100202 IPG 6.63 6.76 6.52 6.72 60275 20100203 IPG 6.73 6.88 6.59 6.69 52549 20100204 IPG 6.63 6.67 6.37 6.41 63721 20100205 IPG 6.57 6.57 6.21 6.39 104504 20100208 IPG 6.44 6.51 6.2875 6.35 72215 20100209 IPG 6.44 6.5 6.31 6.4 83942 20100210 IPG 6.34 6.66 6.33 6.5 79019 20100211 IPG 6.49 6.76 6.4 6.73 62576 20100212 IPG 6.7 6.74 6.6 6.72 54805 20100216 IPG 6.82 6.9 6.77 6.87 42815 20100217 IPG 6.89 7.02 6.84 6.98 59219 20100218 IPG 6.98 7.12 6.92 7.09 46492 20100219 IPG 7.05 7.19 7.02 7.11 31640 20100222 IPG 7.15\n\n---\n\n16.34 16.11 16.27 30563 20100618 WU 16.23 16.35 16.15 16.2 47364 20100621 WU 16.4 16.5 15.92 16 44432 20100622 WU 16 16.08 15.76 15.78 47891 20100623 WU 15.71 15.89 15.505 15.8 45359 20100624 WU 15.73 15.8 15.48 15.53 70021 20100625 WU 15.6 16.04 15.42 16 124921 20100628 WU 16.09 16.1 15.74 15.74 46458 20100629 WU 15.53 15.53 14.83 14.94 110267 20100630 WU 15.01 15.12 14.87 14.91 80619 20100701 WU 14.91 15.11 14.65 15.03 89206 20100702 WU 15.15 15.22 14.83 14.9 58788 20100706 WU 15.17 15.44 14.93 15.06 49627 20100707 WU 15.14 15.85 15.14 15.7875 97018 20100708 WU 15.86 15.95 15.49 15.63 85511 20100709 WU 15.67 15.88 15.55 15.87 41569 20100712 WU 15.79 15.97 15.72 15.9 36248 20100713 WU 16 16.08 15.79 16 85499 20100714 WU 16.03 16.03 15.81 15.96 37854 20100715 WU 15.94 16.03 15.68 15.98 63416 20100716 WU 15.83 15.84 15.22 15.34 96620 20100719 WU 15.36 15.5 15.23 15.37 51674 20100720 WU 15.14 15.7 15.14 15.69 41507 20100721 WU 15.79 15.81 15.35 15.44 56231 20100722 WU 15.61 16.18 15.59 16.04 100536 20100723 WU 16.03 16.34 15.93 16.31 47876 20100726 WU 16.37 16.71 16.3 16.68 91184 20100727 WU 17 17.205 16.57 16.69 96062 20100728 WU 16.62 16.64 16.43 16.47 56360 20100729 WU 16.56 16.67 16.1519 16.41 83881 20100730 WU 15.82 16.44 15.82 16.23 74224 20100802 WU 16.44 16.59 16.07 16.28 81222 20100803 WU 16.24 16.269 15.99 16.03 61259 20100804 WU 16.04 16.15 15.8299 16.13 50838 20100805 WU 16.06 16.29 16.06 16.22 29934 20100806 WU 16.04 16.32 15.97 16.29 48008 20100809 WU 16.37 16.58 16.33 16.54 42737 20100810 WU 16.29 16.66 16.29 16.5 48636 20100811 WU 16.23 16.23 15.99 16.05 47736 20100812 WU 15.81 16.16 15.78 16.06 52099 20100813 WU 15.98 16.17 15.95 15.98 35446 20100816 WU 15.88 16.23 15.82 16.1 28857 20100817 WU 16.18 16.44 16.16 16.18 38698 20100819 WU 16.15 16.21 15.95 16.06 47403 20100820 WU 15.95 16.1 15.88 15.94 35871 20090821 WY 36.29 37.31 35.89 37.02 19789 20090824 WY 37.29 37.45 36.11 36.32 13971 20090825 WY 36.69 37.31 36.27 36.46 17749 20090826 WY 36.54 37.49 36.11 36.79 17052 20090827 WY 36.58 37.44 35.83 37.33 15152 20090828 WY 37.64 37.98 36.92 37.79 15378 20090831 WY 37.16 37.5 36.7 37.39 16364 20090901 WY 37.28 37.92 35.74 35.85 28418 20090902 WY 35.65 36.41 35.39 36.06 19765 20090903 WY 36.29 36.82 35.296 36.75 20133 20090904 WY 36.65 37.15 36.26 37.09 15748 20090909 WY 36.61 37.21 36.35 36.77 18627 20090910 WY 36.62 37.12 36.04 37 20146 20090911 WY 37.11 38.13 36.51 37.29 54748 20090914 WY 36.99 39.66 36.9 39.59 41352 20090915 WY 39.55 40.4346 38.2 39.38 45920 20090916 WY 39.22 39.91 38.61 39.87 24408 20090917 WY 40 40.36 38.42 38.69 28238 20090918 WY 38.8 39.88 38.77 39.65 27009 20090921 WY 39.08 39.68 38.03 38.51 20457 20090922 WY 38.94 39.28 38.62 38.85 13928 20090923 WY 38.89 39.27 38.08 38.13 13837 20090924 WY 38.27 38.36 36.25 36.4 25084 20090925 WY 36.14 37.33 36.11 36.95 18757 20090928 WY 37 37.66 36.58 37.35 9467 20090929 WY 37.35 38.22 37.26 37.38 12214 20090930 WY 37.52 37.61 36.1 36.65 24998 20091001 WY 36.29 36.6 35.68 35.68 30671 20091002 WY 35.61 35.61 34.68 35.08 32382 20091005 WY 35.26 35.56 34.37 35.32 23518 20091006 WY 35.88 36.14 35.25 35.65 21610 20091007 WY 35.54 35.75 34.65 34.88 20476 20091008 WY 35.39 36.62 35.09 36.48 40720 20091009 WY 36.52 36.7 36.11 36.35 25214 20091012 WY 36.435 37.4 36.38 36.83 18638 20091013 WY 36.85 37.85 36.76 37.72 19299 20091014 WY 38.04 39.35 38.04 39.23 28226 20091015 WY 39.06 40.04 38.91 40 26520 20091016 WY 39.79 40.22 39.0106 40.11 30640 20091019 WY 40.01 41 40 40.67 26157 20091020 WY 40.54 40.74 39.98 40.66 21031 20091021 WY 40.5 41.28 40.19 40.26 24603 20091022 WY 40.26 41 39.46 40.83 22412 20091023 WY 40.83 40.83 39.211 39.48 15280 20091026 WY 39.38 40.45 38.21 38.43 22126 20091027 WY 38.33 38.94 38.05 38.18 21814 20091028 WY 37.89 38.5 36.01 36.21 33318 20091105 WY 36.86 38.05 36.86 37.78 22301 20091106 WY 37.24 37.99 36.79 37.62 15183 20091109 WY 37.75 38.87 37.75 38.82 12880 20091110 WY 38.62 38.93 38.091 38.8 12186 20091111 WY 39.04 39.5 38.52 38.9\n\n---\n\n11275 20091125 STZ 17.38 17.48 17.27 17.42 10117 20091127 STZ 17.09 17.2 16.88 16.99 8384 20091130 STZ 17.05 17.24 16.9 17.11 12939 20091201 STZ 17.3 17.46 17.21 17.25 15017 20091202 STZ 16.44 16.8 16.105 16.77 59537 20091203 STZ 16.81 16.81 16.45 16.53 23128 20091204 STZ 16.71 16.97 16.64 16.74 18418 20091207 STZ 16.69 16.89 16.47 16.59 17425 20091208 STZ 16.5 16.52 16.09 16.17 20189 20091209 STZ 16.16 16.19 15.815 15.98 16213 20091210 STZ 16.01 16.16 15.69 15.81 22973 20091211 STZ 15.83 16.01 15.79 15.98 15597 20091214 STZ 16.15 16.15 16.01 16.08 15580 20091215 STZ 16.06 16.21 16.06 16.17 10457 20091216 STZ 15.66 15.8 15.02 15.11 62654 20091217 STZ 15.08 15.17 14.91 15.12 31853 20091218 STZ 15.13 15.42 15.11 15.35 45756 20091221 STZ 15.45 15.52 15.29 15.48 21955 20091222 STZ 15.54 15.78 15.38 15.74 16545 20091223 STZ 15.84 15.87 15.61 15.77 10092 20091224 STZ 15.78 15.93 15.77 15.92 3494 20091228 STZ 15.88 16.05 15.86 16.05 7308 20091229 STZ 16.04 16.12 15.97 15.97 8880 20091230 STZ 15.99 16.01 15.83 15.99 6262 20091231 STZ 15.98 16.076 15.92 15.93 8433 20100104 STZ 16.02 16.17 15.89 16.12 14187 20100105 STZ 16.08 16.13 15.86 15.92 24315 20100106 STZ 15.94 16.17 15.72 16.13 28393 20100107 STZ 15.6 16.2 15.1 15.97 38706 20100108 STZ 15.88 15.88 15.55 15.66 21002 20100111 STZ 15.66 15.8 15.53 15.69 15359 20100112 STZ 15.63 15.75 15.52 15.65 17628 20100113 STZ 15.64 15.995 15.61 15.91 15187 20100114 STZ 15.98 16.48 15.98 16.33 24669 20100115 STZ 16.37 16.55 16.29 16.41 23846 20100119 STZ 16.38 16.84 16.38 16.82 23345 20100120 STZ 16.66 16.835 16.54 16.83 26553 20100121 STZ 16.72 17.04 16.72 16.79 24022 20100122 STZ 16.71 16.85 16.5 16.61 21100 20100125 STZ 16.8 16.8 16.46 16.61 12742 20100126 STZ 16.47 16.62 16.41 16.42 10011 20100127 STZ 16.4 16.48 16.06 16.34 11205 20100128 STZ 16.41 16.45 16.1 16.17 7348 20100129 STZ 16.23 16.27 16.03 16.08 14613 20100201 STZ 16.18 16.29 16.07 16.23 9985 20100202 STZ 16.28 16.42 16.1185 16.39 8290 20100203 STZ 16.36 16.42 16.19 16.31 6851 20100204 STZ 16.16 16.2 15.41 15.45 19938 20100205 STZ 15.4 15.51 14.95 15.33 32114 20100208 STZ 15.37 15.37 14.87 14.93 22056 20100209 STZ 15.17 15.33 14.96 15.2 15097 20100210 STZ 15.17 15.24 14.91 15.13 16157 20100211 STZ 15.18 15.53 15.08 15.49 13514 20100212 STZ 15.38 15.59 15.28 15.36 19741 20100216 STZ 15.43 15.61 15.37 15.61 8394 20100217 STZ 15.65 15.84 15.55 15.68 13603 20100218 STZ 15.61 15.8 15.56 15.59 14479 20100219 STZ 15.48 15.625 15.33 15.6 15898 20100222 STZ 15.61 15.68 15.47 15.53 9583 20100223 STZ 15.46 15.46 15.03 15.22 22399 20100224 STZ 15.24 15.25 14.96 15.02 27108 20100225 STZ 14.85 14.91 14.6 14.83 43600 20100226 STZ 14.9 15.09 14.83 15.04 16115 20100301 STZ 15.15 15.26 15.06 15.26 10710 20100302 STZ 15.29 15.52 15.21 15.47 13649 20100303 STZ 15.45 15.66 15.42 15.43 14983 20100304 STZ 15.39 15.59 15.36 15.57 10967 20100305 STZ 15.65 15.85 15.58 15.81 11186 20100308 STZ 15.82 15.83 15.67 15.78 15965 20100309 STZ 15.71 15.92 15.67 15.81 18154 20100310 STZ 15.83 15.88 15.54 15.62 18492 20100311 STZ 15.55 15.83 15.54 15.83 11045 20100312 STZ 15.83 16.14 15.83 16.11 16270 20100315 STZ 16.06 16.23 15.96 16.13 10765 20100316 STZ 16.11 16.23 15.99 16.17 8225 20100317 STZ 16.18 16.28 16.09 16.24 8283 20100318 STZ 16.215 16.3 16.03 16.19 15191 20100319 STZ 16.25 16.31 15.96 16 17313 20100322 STZ 15.91 16.15 15.85 16.11 12863 20100323 STZ 16.08 16.39 16.03 16.37 10701 20100324 STZ 16.28 16.38 16.13 16.22 10449 20100325 STZ 16.35 16.39 16.16 16.18 11964 20100326 STZ 16.21 16.225 16 16.01 11169 20100329 STZ 16.06 16.35 16.05 16.31 9871 20100330 STZ 16.36 16.57 16.36 16.42 9572 20100331 STZ 16.39 16.56 16.2799 16.44 13696 20100401 STZ 16.51 16.6 16.33 16.5 12125 20100405 STZ 16.51 16.72 16.43 16.67 8231 20100406 STZ 16.74 17.01 16.6 17 14899 20100407 STZ 16.9 17.12 16.83 16.84 16576 20100408 STZ 16.85 17 16.77 16.85 22161 20100409 STZ 16.01 16.54 15.95 16.43 49175 20100412 STZ 16.47 17.23 16.28 17.15 39231 20100413 STZ 17.09 17.1501 16.89 17.07\n\n---\n\n21.79 49643 20091020 NVLS 21.69 22.07 21.65 21.83 55248 20091021 NVLS 21.73 21.99 21.5 21.61 61336 20091022 NVLS 21.79 23.13 21.34 23.08 86835 20091023 NVLS 23.03 23.17 22.3 22.5 55483 20091026 NVLS 22.55 22.91 22.15 22.31 45552 20091027 NVLS 22.19 22.59 21.52 21.62 38032 20091028 NVLS 21.65 21.87 20.8 20.82 33470 20091105 NVLS 20.04 20.41 19.94 20.27 20684 20091106 NVLS 20.22 20.62 20.11 20.37 18873 20091109 NVLS 20.58 21.11 20.57 21.07 16542 20091110 NVLS 21.05 21.28 20.9 21.16 24642 20091111 NVLS 21.24 21.73 21.2 21.55 18712 20091113 NVLS 21.35 21.64 21.2 21.63 21774 20091116 NVLS 21.71 22.42 21.71 22.32 27889 20091117 NVLS 22.09 22.36 21.92 22.17 17857 20091118 NVLS 22.18 22.22 21.76 21.8 14999 20091119 NVLS 21.55 21.59 20.82 20.89 30592 20091120 NVLS 20.8 21.035 20.66 20.96 46268 20091123 NVLS 21.2 21.58 21.06 21.22 19611 20091124 NVLS 21.13 21.25 20.73 20.96 21300 20091125 NVLS 21.02 21.2 20.93 21.06 10300 20091127 NVLS 20.4 20.93 20.28 20.72 6156 20091130 NVLS 20.77 20.8 20.4 20.69 13480 20091201 NVLS 20.84 21.34 20.86 21.28 11524 20091202 NVLS 21.28 21.79 21.22 21.74 25333 20091203 NVLS 21.8 22.5 21.63 22.35 35046 20091204 NVLS 22.98 23.44 22.73 23.36 49869 20091207 NVLS 23.34 23.635 23.31 23.52 21120 20091208 NVLS 23.41 23.9599 23.13 23.81 28519 20091209 NVLS 23.72 24.06 23.525 24.03 18202 20091210 NVLS 24.03 24.33 23.78 23.85 17509 20091211 NVLS 23.91 24.12 23.59 23.8 12876 20091214 NVLS 23.97 24.21 23.84 24.11 14186 20091215 NVLS 23.92 24.32 23.86 24.12 13214 20091216 NVLS 24.14 24.7 24.06 24.49 16742 20091217 NVLS 24.22 24.425 23.79 23.93 14684 20091218 NVLS 24.02 24.15 23.655 23.94 21004 20091221 NVLS 23.84 26 23.78 24.09 29202 20091222 NVLS 24.04 24.1 23.81 23.86 19917 20091223 NVLS 23.8 23.9199 23.5 23.56 19619 20091224 NVLS 23.58 23.6125 23.49 23.6 10032 20091228 NVLS 23.64 23.64 23.33 23.51 13430 20091229 NVLS 23.54 23.61 23.4 23.41 9227 20091230 NVLS 23.33 23.49 23.32 23.45 24282 20091231 NVLS 23.32 23.76 23.25 23.34 16627 20100104 NVLS 23.5 23.89 23.45 23.7 19723 20100105 NVLS 23.76 23.87 23.59 23.74 15063 20100106 NVLS 23.68 24.03 23.38 23.42 21068 20100107 NVLS 23.21 23.48 23.05 23.38 12860 20100108 NVLS 23.41 24.13 23.24 24.06 26343 20100111 NVLS 24.2 24.22 23.57 24.02 16844 20100112 NVLS 23.84 23.95 22.74 22.8 32847 20100113 NVLS 22.85 23.32 22.54 23.26 24208 20100114 NVLS 23.12 23.4 22.8 23.05 22681 20100115 NVLS 22.9 22.95 21.9886 22.13 36043 20100119 NVLS 22.13 22.61 21.98 22.43 20401 20100120 NVLS 22.3 22.5 22.01 22.43 21007 20100121 NVLS 22.43 22.87 22.08 22.13 23901 20100122 NVLS 21.68 21.72 20.9 20.97 46535 20100125 NVLS 21.13 21.54 20.89 21.44 37618 20100126 NVLS 21.93 22.58 21.83 22.07 79965 20100127 NVLS 22.07 22.56 21.83 22.28 39324 20100128 NVLS 22.33 22.37 21.26 21.5 44998 20100129 NVLS 21.71 21.932 20.68 20.9 36505 20100201 NVLS 20.98 21.63 20.93 21.59 30508 20100202 NVLS 21.58 22.03 21.49 21.76 28696 20100203 NVLS 21.6 22.16 21.58 22.05 45268 20100204 NVLS 21.15 21.48 20.57 21.0775 59882 20100205 NVLS 21.24 21.64 20.83 21.6 42846 20100208 NVLS 21.53 21.93 21.25 21.48 25722 20100209 NVLS 21.79 21.96 21.43 21.78 24356 20100210 NVLS 21.7 21.99 21.5 21.8 22676 20100211 NVLS 21.77 22.4 21.52 22.33 23325 20100212 NVLS 22.1 22.79 21.8 22.47 22931 20100216 NVLS 22.64 23.105 22.54 23.09 22476 20100217 NVLS 23.12 23.21 22.57 22.73 22070 20100218 NVLS 22.58 22.67 22.215 22.65 22104 20100219 NVLS 22.65 22.8 22.5 22.71 19720 20100222 NVLS 22.74 22.93 22.47 22.65 15305 20100223 NVLS 22.54 22.58 21.51 21.73 31158 20100224 NVLS 21.87 22.44 21.81 22.27 25055 20100225 NVLS 21.96 22.19 21.56 22.13 19765 20100226 NVLS 22.04 22.18 21.81 22.12 16217 20100301 NVLS 22.27 22.63 22.1 22.54 19838 20100302 NVLS 22.67 23.05 22.66 22.81 24363 20100303 NVLS 22.79 23.13 22.65 22.77 13248 20100304 NVLS 22.73 22.79 22.31 22.48 16162 20100305 NVLS 22.59 22.95 22.47 22.83 17163 20100308 NVLS 22.81 23.1 22.82 23 19270 20100309 NVLS 22.86 23.02 22.69 22.88 18733 20100310 NVLS 22.78 23.4 22.75 23.31 21850 20100311 NVLS 23.41\n\n---\n\nTER 10.78 10.79 10.37 10.5 49902 20100728 TER 10.37 10.5 10.05 10.21 73248 20100729 TER 11.1 11.24 10.8 11.07 226299 20100730 TER 10.84 10.88 10.53 10.76 73524 20100802 TER 11.08 11.31 10.96 11.25 75720 20100803 TER 11.2 11.2278 10.95 11.05 48837 20100804 TER 11.09 11.21 10.9 11.11 38024 20100805 TER 11.01 11.26 10.89 11.15 76524 20100806 TER 10.98 11.15 10.83 10.84 62964 20100809 TER 10.95 10.99 10.85 10.89 43971 20100810 TER 10.79 10.79 10.32 10.45 62542 20100811 TER 10.09 10.14 9.82 9.88 82657 20100812 TER 9.58 9.88 9.39 9.56 109118 20100813 TER 9.5 9.78 9.5 9.61 53050 20100816 TER 9.58 9.61 9.41 9.5 84824 20100817 TER 9.63 9.79 9.52 9.7 83035 20100819 TER 9.84 10.01 9.63 9.68 58292 20100820 TER 9.6 9.72 9.43 9.49 47867 20090821 TGT 45.6 45.87 45.13 45.66 60965 20090824 TGT 45.89 45.89 45.09 45.17 65388 20090825 TGT 45.57 46.83 45.27 46.47 110871 20090826 TGT 46.31 47.69 46.26 47.42 101865 20090827 TGT 47.29 47.55 46.81 47.29 71972 20090828 TGT 47.63 47.63 47.01 47.39 66010 20090831 TGT 47.02 47.21 46.5 47 81053 20090901 TGT 46.72 47.55 46.32 46.58 103778 20090902 TGT 46.38 46.78 45.68 46.27 80356 20090903 TGT 47.59 47.75 46.79 47.07 122391 20090904 TGT 47.17 47.36 46.87 47.12 60528 20090909 TGT 47.27 47.78 46.99 47.65 80033 20090910 TGT 47.67 48.21 47.4 48.17 68484 20090911 TGT 48.25 48.45 47.59 47.95 62097 20090914 TGT 47.69 48.04 47.32 47.42 66835 20090915 TGT 47.51 47.95 46.86 47.51 71046 20090916 TGT 47.62 48.5 47.62 48.47 65794 20090917 TGT 48.36 49.14 48.33 48.67 71467 20090918 TGT 48.84 48.93 48.48 48.79 62745 20090921 TGT 48.52 49.2 47.85 48.84 40712 20090922 TGT 48.92 48.96 48.04 48.16 69677 20090923 TGT 48.17 48.38 47.5 47.56 56197 20090924 TGT 47.63 48.04 47 47.65 53845 20090925 TGT 47.69 47.69 46.15 46.29 84146 20090928 TGT 46.57 47.83 46.35 47.71 60219 20090929 TGT 47.81 48.17 47.2 47.28 54730 20090930 TGT 46.95 47.19 46.28 46.68 93891 20091001 TGT 46.52 47.04 46 46.57 72290 20091002 TGT 46.03 46.54 45.73 46.02 60946 20091005 TGT 46.17 47.11 46.09 46.93 53983 20091006 TGT 47.59 48.18 47.59 48.09 70758 20091007 TGT 47.97 48.66 47.85 48.51 73116 20091008 TGT 47.7 49.64 47.52 49.34 120953 20091009 TGT 49.41 49.95 49.09 49.89 82513 20091012 TGT 50 50.75 49.54 49.6 72731 20091013 TGT 49.63 50.855 49.61 50.1 76764 20091014 TGT 50.92 51.77 50.3 51.35 92849 20091015 TGT 51.11 51.15 50 50.42 86297 20091016 TGT 50.27 50.33 49.65 50.08 67691 20091019 TGT 50.26 50.695 50.05 50.39 51676 20091020 TGT 50.25 50.8 49.51 49.97 43382 20091021 TGT 50.26 50.76 48.81 48.9 78832 20091022 TGT 49.01 49.95 48.82 49.49 68381 20091023 TGT 49.81 50.2 48.8 49.03 59717 20091026 TGT 49.15 50 48.62 48.88 49530 20091027 TGT 48.88 49.33 48.16 48.45 65328 20091028 TGT 49.08 49.58 48.15 48.24 95711 20091105 TGT 49.26 49.78 48.41 49.7 82774 20091106 TGT 49.6 49.97 49.15 49.7 52935 20091109 TGT 49.94 50.49 49.55 50.45 87926 20091110 TGT 50.43 50.85 49.94 50.49 48332 20091111 TGT 50.77 51.02 49.8 50.11 53039 20091112 TGT 50.12 50.39 48.7 48.93 92526 20091113 TGT 48.98 49.12 48.17 48.99 100288 20091116 TGT 49.3 50.34 49.25 50.29 109841 20091117 TGT 50.48 50.59 47.48 48.77 234946 20091118 TGT 48.25 48.26 47.72 47.87 115934 20091119 TGT 47.94 48.13 47.48 47.9 87472 20091120 TGT 47.73 48.18 47.2 47.46 77295 20091123 TGT 47.92 47.93 47.16 47.26 71771 20091124 TGT 47.1 47.55 47.05 47.46 58629 20091125 TGT 47.52 48.05 47.38 47.83 43343 20091127 TGT 46.92 47.94 46.62 47.7 42442 20091130 TGT 47.45 47.67 45.99 46.56 128686 20091201 TGT 47.075 47.25 46.643 46.78 95429 20091202 TGT 46.75 47.79 46.67 47.72 112673 20091203 TGT 47.08 47.25 46.05 46.35 143680 20091204 TGT 46.9 47.19 45.17 45.64 175116 20091207 TGT 45.64 46.5 45.64 46.34 86425 20091208 TGT 46.2 46.2 45.42 45.87 63704 20091209 TGT 45.7 45.73 45.11 45.3 66434 20091210 TGT 45.66 46.17 45.17 45.99 77462 20091211 TGT 46.17 47.02 46.07 46.93 75531 20091214 TGT 47.21 47.91 46.915 47.84 89795 20091215 TGT 47.76 47.9 47.37 47.66 70233 20091216 TGT 47.88 48 47.46 47.48 53659 20091217 TGT 47.34 47.94 47.1 47.5\n\n---\n\n14.78 15.06 39829 20100203 SVU 15 15.02 14.65 14.73 34319 20100204 SVU 14.62 14.83 14.41 14.44 44919 20100205 SVU 14.39 14.6 14.3 14.59 38565 20100208 SVU 14.61 14.635 14.32 14.42 26670 20100209 SVU 14.56 14.855 14.49 14.8 36052 20100210 SVU 14.76 14.98 14.59 14.82 29467 20100211 SVU 14.77 14.965 14.58 14.91 25995 20100212 SVU 14.82 14.93 14.55 14.77 39867 20100216 SVU 14.83 15.23 14.72 15.2 37648 20100217 SVU 15.2 15.48 15.14 15.44 31622 20100218 SVU 15.33 15.84 15.33 15.72 32338 20100219 SVU 15.7 15.88 15.53 15.79 30517 20100222 SVU 15.75 15.87 15.67 15.68 13380 20100223 SVU 15.64 15.64 15.22 15.29 30150 20100224 SVU 15.35 15.38 15.19 15.27 34167 20100225 SVU 14.94 15.29 14.79 15.26 46714 20100226 SVU 15.29 15.32 15.05 15.27 37861 20100301 SVU 15.29 15.69 15.27 15.65 26473 20100302 SVU 15.71 15.99 15.63 15.88 36556 20100303 SVU 15.77 15.965 15.55 15.71 39995 20100304 SVU 15.71 16 15.57 15.99 32701 20100305 SVU 16 16.04 15.8 15.86 38250 20100308 SVU 15.89 16.16 15.79 16.15 25231 20100309 SVU 16.2 16.5 16.01 16.16 50442 20100310 SVU 16.19 16.28 15.96 16.09 32797 20100311 SVU 16.04 16.07 15.75 16.07 22747 20100312 SVU 16.06 17.89 15.86 17.13 181447 20100315 SVU 17.02 17.71 16.77 17.37 52422 20100316 SVU 17.37 17.51 17.2 17.33 30381 20100317 SVU 17.29 17.6 17.25 17.47 27149 20100318 SVU 17.41 17.46 17.07 17.14 29966 20100319 SVU 17.06 17.08 16.54 16.73 54520 20100322 SVU 16.61 16.86 16.26 16.75 38005 20100323 SVU 16.72 16.91 16.52 16.91 21829 20100324 SVU 16.81 16.86 16.43 16.59 27599 20100325 SVU 16.76 16.76 16.46 16.49 30288 20100326 SVU 16.52 16.57 16.15 16.22 24912 20100329 SVU 16.41 16.42 16.24 16.31 22630 20100330 SVU 16.38 16.92 16.27 16.8 57848 20100331 SVU 16.8 16.8 16.63 16.68 26161 20100401 SVU 16.79 16.89 16.64 16.77 20968 20100405 SVU 16.85 16.99 16.74 16.9 23779 20100406 SVU 16.82 16.86 16.745 16.82 26570 20100407 SVU 16.73 16.87 16.5 16.58 38598 20100408 SVU 16.56 16.56 16.24 16.42 33629 20100409 SVU 16.38 16.6 16.28 16.4 32615 20100412 SVU 16.55 17 16.51 16.83 36090 20100413 SVU 16.82 16.95 16.67 16.89 19125 20100414 SVU 16.9 16.93 16.52 16.84 31962 20100415 SVU 16.78 17.21 16.66 17.16 40345 20100416 SVU 17.36 17.44 16.83 16.98 62706 20100419 SVU 17 17.31 16.85 17.14 52141 20100420 SVU 16.51 17.47 16.04 16.27 109638 20100421 SVU 16.25 16.42 15.96 16.29 57804 20100422 SVU 16.14 16.26 15.99 16.09 36478 20100423 SVU 16.16 16.16 15.76 16 37069 20100426 SVU 15.88 16 15.27 15.36 64726 20100427 SVU 15.23 15.3 14.9 14.96 59777 20100428 SVU 15.05 15.225 14.93 14.99 45830 20100429 SVU 15.08 15.29 14.76 15.17 43139 20100430 SVU 15.12 15.25 14.78 14.9 41400 20100503 SVU 14.98 15.18 14.85 15.08 35072 20100504 SVU 14.92 15.04 14.72 14.77 39282 20100505 SVU 14.69 15.15 14.6 15 38108 20100506 SVU 14.93 14.95 13.19 13.99 79797 20100507 SVU 13.97 14.09 13.34 13.4 79470 20100510 SVU 13.99 14.08 13.56 13.76 50606 20100511 SVU 13.63 14.18 13.58 13.86 36799 20100512 SVU 13.87 14.13 13.79 14.1 32452 20100513 SVU 14.1 14.24 13.8 13.83 38704 20100514 SVU 13.83 13.85 13.55 13.64 28929 20100517 SVU 13.59 13.79 13.26 13.75 40862 20100518 SVU 13.9 14.05 13.7 13.72 27665 20100519 SVU 13.63 13.91 13.55 13.72 34152 20100520 SVU 13.45 13.45 12.86 12.86 46574 20100521 SVU 12.82 13.269 12.65 13.23 51135 20100524 SVU 12.99 13.24 12.99 13.15 39308 20100525 SVU 12.72 13.32 12.5 13.24 61137 20100526 SVU 13.54 13.775 13.38 13.44 47323 20100527 SVU 13.47 13.66 13.27 13.61 33389 20100528 SVU 13.67 13.91 13.4 13.47 32111 20100601 SVU 13.31 13.46 13 13 34254 20100602 SVU 13.06 13.24 12.83 13.05 38294 20100603 SVU 13.12 13.27 12.895 13.05 28932 20100604 SVU 12.81 12.99 12.65 12.68 32328 20100607 SVU 12.63 12.72 12.22 12.34 41640 20100608 SVU 12.33 12.34 11.95 12.17 41289 20100609 SVU 12.2 12.43 11.93 11.99 35742 20100610 SVU 12.16 12.5 12.16 12.49 29650 20100611 SVU 12.43 12.43 12.17 12.24 30059 20100614 SVU 12.33 12.49 12.21 12.36 24366 20100615 SVU 12.51 12.83 12.37 12.76 25920 20100616 SVU 12.67 12.94 12.46 12.48 40824 20100617 SVU 12.76 13.26 12.73\n\n---\n\nESRX 90.6 91.07 87.24 88.83 28801 20100121 ESRX 88.43 88.71 85.57 86.33 26789 20100122 ESRX 86.06 87.41 85.07 85.2 32635 20100125 ESRX 85.51 86.495 85.2 85.81 16620 20100126 ESRX 85.56 85.93 84.9 85.2 15413 20100127 ESRX 84.86 85.98 84.15 85.6 17227 20100128 ESRX 85.63 86.46 84.46 84.9 17160 20100129 ESRX 85.45 85.64 83.86 83.86 20230 20100201 ESRX 84.03 85.56 83.16 85.56 19174 20100202 ESRX 85.25 87.1 84.76 87.03 17461 20100203 ESRX 86.09 86.67 85.31 86.44 16257 20100204 ESRX 85.94 85.94 84.32 84.32 24721 20100205 ESRX 84.62 85.31 82.76 84.82 32830 20100208 ESRX 85.07 85.39 84.17 84.5 16203 20100209 ESRX 85.39 86.12 84.22 85.24 15291 20100210 ESRX 85 85.86 84.41 84.97 15533 20100211 ESRX 84.93 87.22 84.71 86.76 21124 20100212 ESRX 85.94 86.54 85.43 86.43 16092 20100216 ESRX 86.955 87.45 85.7 87.3 11884 20100217 ESRX 87.89 89.48 87.2765 88.8 16630 20100218 ESRX 89.04 90.11 88.81 89.75 16079 20100219 ESRX 89.65 90.39 89.27 90.12 20416 20100222 ESRX 90.34 90.944 89.13 89.37 24038 20100223 ESRX 88.89 88.915 87.33 87.99 23010 20100224 ESRX 88.32 89.2 87.43 87.75 35694 20100225 ESRX 96.32 96.66 93.65 95.23 82902 20100226 ESRX 95.19 96.42 94.5 96.01 24253 20100301 ESRX 95.03 97.19 95 96.44 25281 20100302 ESRX 96.84 98.79 96.36 98.67 32154 20100303 ESRX 98.69 99.45 98.311 98.99 29149 20100304 ESRX 98.64 99.58 98.37 99.02 28499 20100305 ESRX 98.63 99.51 98.49 99.445 26148 20100308 ESRX 98.6 99.45 98.02 98.29 18110 20100309 ESRX 97.94 99.04 97.78 98.33 14493 20100310 ESRX 97.99 99.06 97.97 98.59 12391 20100311 ESRX 98.57 99.25 97.74 99.25 15884 20100312 ESRX 99.84 99.95 98.57 98.94 15323 20100315 ESRX 98.91 99.91 98.4215 99.9 21648 20100316 ESRX 100 100.5 98.58 99.67 14379 20100317 ESRX 99.57 100 98.23 99.01 13036 20100318 ESRX 98.79 99.64 98.3701 99.64 15347 20100319 ESRX 101.08 101.11 99.5 100.73 28481 20100322 ESRX 101.4 103.24 101.26 102.18 25439 20100323 ESRX 102.54 102.73 101.31 102 21926 20100324 ESRX 101.99 102.29 100.81 100.83 12615 20100325 ESRX 101.68 101.7 100.11 100.58 15583 20100326 ESRX 100.78 101.31 99.575 100.62 14866 20100329 ESRX 100.84 102.4 100.58 102.24 13829 20100330 ESRX 102.04 102.5 100.95 101.6 10356 20100331 ESRX 101.25 102.1 100.39 101.76 11203 20100401 ESRX 102.36 103 101.43 102.39 12645 20100405 ESRX 102.75 102.99 102.02 102.4 8347 20100406 ESRX 101.77 102.75 101.72 102.06 8696 20100407 ESRX 102.25 102.57 101.175 101.68 12759 20100408 ESRX 101.51 103.53 100.95 103.06 18408 20100409 ESRX 103.21 103.8 102.7 103.31 13921 20100412 ESRX 103.26 103.37 101.82 102.43 13235 20100413 ESRX 102.05 103.09 100.31 102.94 19532 20100414 ESRX 102.95 103.31 99.81 100.54 32484 20100415 ESRX 100.4 101.04 98.23 98.89 31134 20100416 ESRX 99.03 100.96 98.64 100.78 27784 20100419 ESRX 100.69 103.07 100.13 102.79 22872 20100420 ESRX 103.25 105 102.25 104.91 19466 20100421 ESRX 104.42 104.87 102.94 103.67 19219 20100422 ESRX 103.51 103.8 102.29 103.1 13636 20100423 ESRX 103.09 104.24 102.39 104.19 14652 20100426 ESRX 103.79 104.69 102.34 102.75 13640 20100427 ESRX 103.43 105 102.3 102.3 25463 20100428 ESRX 103.27 103.71 100.06 101.68 33725 20100429 ESRX 99.45 104.13 99.32 102.89 42047 20100430 ESRX 102.41 103.27 99.79 100.13 26235 20100503 ESRX 100.1 101.23 98.26 100.46 24023 20100504 ESRX 99.12 101.24 98.65 99.94 27019 20100505 ESRX 99.87 103.18 99.98 102.49 24813 20100506 ESRX 102.58 104.25 75.5 99.6 53326 20100507 ESRX 99.31 99.89 96.31 97.15 41659 20100510 ESRX 100.82 104.42 99.72 104.37 40675 20100511 ESRX 102.93 104.37 102.68 103.17 32703 20100512 ESRX 103.5 105.07 102.4 104.13 22860 20100513 ESRX 103.84 104.66 102.73 103.66 21568 20100514 ESRX 103.43 103.75 100.84 101.69 29054 20100517 ESRX 102.2 103.76 101.7 103.12 23495 20100518 ESRX 102.95 106.3 102.53 104.13 31714 20100519 ESRX 104.1 104.93 103.08 103.77 30056 20100520 ESRX 101.555 102.2 99.31 99.51 36975 20100521 ESRX 97.75 101.54 97.51 100.59 38947 20100524 ESRX 100 101.54 98.66 100.32 22700 20100525 ESRX 98.44 99.89 97.55 99.13 29789 20100526 ESRX 98.99 101.58 98.42\n\n---\n\nIP 26.19 26.19 24.81 25.01 111810 20100505 IP 24.6 25.45 24.3 24.76 79523 20100506 IP 24.55 25.16 20.5 23.34 152968 20100507 IP 22.23 23.8 21.53 23.16 151037 20100510 IP 25.01 25.45 24.22 24.79 80144 20100511 IP 24.49 24.88 24.11 24.29 57643 20100512 IP 24.47 24.96 24.33 24.93 60708 20100513 IP 24.72 24.92 24.22 24.31 56798 20100514 IP 23.96 24.04 23.46 23.78 88910 20100517 IP 23.92 24.37 23.03 23.6 92272 20100518 IP 23.97 24.33 22.87 22.93 63032 20100519 IP 22.66 22.84 21.72 22.52 101373 20100520 IP 21.68 22.3 21.23 21.76 139729 20100521 IP 21.18 22.715 21.09 22.28 100026 20100524 IP 22.13 22.53 21.74 21.75 62640 20100525 IP 20.94 22.26 20.77 22.23 93577 20100526 IP 22.58 23.25 22.06 22.34 74161 20100527 IP 23.04 23.77 22.735 23.76 75154 20100528 IP 23.7 23.83 23 23.23 59553 20100601 IP 22.82 23.35 22.23 22.24 55603 20100602 IP 22.34 22.99 22.25 22.97 57310 20100603 IP 23.09 23.68 22.84 23.39 71894 20100604 IP 22.74 23.12 21.86 21.93 79610 20100607 IP 22.01 22.06 21.05 21.08 104412 20100608 IP 21.07 21.72 21.04 21.64 87785 20100609 IP 21.9 22.69 21.75 21.87 73330 20100610 IP 22.34 23.03 22.34 23.02 58326 20100611 IP 23.29 24.37 23.02 24.3 92418 20100614 IP 24.71 25.7 24.67 25.05 127536 20100615 IP 25.4 26.23 25.08 26.2 96960 20100616 IP 25.83 26.04 25.48 25.66 63937 20100617 IP 25.8 25.85 25.055 25.52 64414 20100618 IP 25.64 25.92 25.48 25.73 64886 20100621 IP 26.48 26.97 26.16 26.31 75897 20100622 IP 26.26 26.57 24.26 24.35 110304 20100623 IP 24.26 25.27 23.98 25.2 108442 20100624 IP 25.05 25.155 23.61 23.72 93955 20100625 IP 23.79 24.64 23.54 24.59 167774 20100628 IP 24.48 24.72 23.79 23.99 68957 20100629 IP 23.37 23.46 22.18 22.39 118859 20100630 IP 22.38 23.29 22.3 22.63 104325 20100701 IP 22.75 23.18 21.96 22.94 94779 20100702 IP 23.15 23.33 22.25 22.59 63090 20100706 IP 23.22 23.34 22.04 22.33 57045 20100707 IP 22.23 23.14 22.23 23.13 63684 20100708 IP 23.28 23.4962 22.73 23.15 82415 20100709 IP 23.1 23.86 23.1 23.67 50069 20100712 IP 23.7 23.81 23.09 23.32 62081 20100713 IP 23.79 24.41 23.71 24.14 64604 20100714 IP 24.11 24.12 23.43 23.79 63058 20100715 IP 23.81 23.81 22.97 23.59 53369 20100716 IP 23.44 23.57 22.71 22.78 65073 20100719 IP 23 23.17 22.4 23.06 55045 20100720 IP 22.74 24.28 22.49 24.28 74028 20100721 IP 24.53 24.65 23.33 23.49 60497 20100722 IP 23.84 24.75 23.76 24.59 56775 20100723 IP 24.56 25.06 24.36 24.98 54742 20100726 IP 25.16 25.52 24.82 25.5 54617 20100727 IP 25.76 25.79 25 25.49 70485 20100728 IP 24.62 24.85 23.44 24.12 131894 20100729 IP 24.42 24.787 23.82 24.09 85452 20100730 IP 23.75 24.34 23.63 24.2 48365 20100802 IP 24.71 25.28 24.56 25.18 62694 20100803 IP 24.8 25 24.385 24.51 52540 20100804 IP 24.75 24.88 24.28 24.54 38148 20100805 IP 24.39 24.83 24.3 24.63 46446 20100806 IP 24.35 24.67 23.49 24.06 66788 20100809 IP 24.28 24.46 23.66 23.69 51098 20100810 IP 23.45 23.49 22.65 22.91 90756 20100811 IP 22.51 22.54 21.84 21.87 67713 20100812 IP 21.45 22.14 21.18 21.87 61139 20100813 IP 21.75 22.16 21.67 21.87 43635 20100816 IP 21.72 22.22 21.42 21.59 80492 20100817 IP 21.97 22.22 21.65 21.99 62589 20100819 IP 21.65 21.82 21.11 21.28 53084 20100820 IP 21.03 21.42 20.95 21.21 47184 20090821 IPG 6.16 6.72 6.16 6.47 79450 20090824 IPG 6.48 6.58 6.38 6.44 64236 20090825 IPG 6.49 6.61 6.36 6.56 46042 20090826 IPG 6.57 6.6 6.29 6.4 68224 20090827 IPG 6.43 6.54 6.16 6.52 52959 20090828 IPG 6.6 6.64 6.29 6.42 54489 20090831 IPG 6.31 6.42 6.1799 6.29 45113 20090901 IPG 6.23 6.54 6.14 6.15 73594 20090902 IPG 6.22 6.22 5.87 6.01 76939 20090903 IPG 6.04 6.08 5.94 5.99 53393 20090904 IPG 6.01 6.19 6.01 6.18 48811 20090909 IPG 6.42 6.68 6.27 6.66 71326 20090910 IPG 6.68 6.84 6.55 6.82 47459 20090911 IPG 6.76 6.87 6.65 6.75 42393 20090914 IPG 6.68 6.78 6.53 6.59 56535 20090915 IPG 6.7 7.29 6.48 7.18 133990 20090916 IPG 7.24 7.37 7.04 7.36 89323 20090917 IPG 7.32 7.39 7.12 7.28 66142 20090918 IPG 7.35 7.56 7.35 7.47 60774 20090921 IPG 7.4 7.49 7.13 7.4 62907 20090922 IPG 7.18 7.45 7.16 7.2 51463 20090923 IPG\n\n---\n\nFIS 22.56 22.78 22.41 22.61 37029 20100219 FIS 22.48 22.79 22.42 22.68 28900 20100222 FIS 22.71 22.84 22.6 22.65 18346 20100223 FIS 22.65 22.81 22.45 22.6 26523 20100224 FIS 22.68 22.92 22.445 22.88 33282 20100225 FIS 22.61 22.83 22.52 22.8 42534 20100226 FIS 22.78 22.78 22.5 22.54 49756 20100301 FIS 22.56 23.07 22.54 23.07 19697 20100302 FIS 23 23.2 22.93 22.98 17841 20100303 FIS 22.98 23.18 22.86 22.93 18112 20100304 FIS 22.99 23.05 22.84 23.03 14635 20100305 FIS 23.11 23.5 22.98 23.48 17961 20100308 FIS 23.45 23.51 23.32 23.4 14906 20100309 FIS 23.25 23.34 23.08 23.14 40134 20100310 FIS 23.1 23.18 22.95 23.18 27856 20100311 FIS 23.24 23.3 23.09 23.2 23490 20100312 FIS 23.16 23.2 23.02 23.19 15581 20100315 FIS 23.15 23.39 23.04 23.35 17276 20100316 FIS 23.33 23.53 23.28 23.52 18515 20100317 FIS 23.51 23.99 23.48 23.83 29083 20100318 FIS 23.74 23.83 23.5 23.57 20862 20100319 FIS 23.63 23.75 23.48 23.63 34318 20100322 FIS 23.57 23.85 23.49 23.71 14876 20100323 FIS 23.78 23.83 23.59 23.77 10744 20100324 FIS 23.75 23.75 23.56 23.59 12198 20100325 FIS 23.67 23.78 23.38 23.39 18051 20100326 FIS 23.38 23.76 23.31 23.66 20871 20100329 FIS 23.79 23.82 23.46 23.57 20572 20100330 FIS 23.58 23.63 23.31 23.43 18124 20100331 FIS 23.33 23.47 23.25 23.44 19412 20100401 FIS 23.5 23.78 23.48 23.69 22200 20100405 FIS 23.72 23.86 23.66 23.82 11654 20100406 FIS 23.73 23.98 23.655 23.9 17859 20100407 FIS 23.82 24.27 23.75 24.21 46757 20100408 FIS 24.11 24.4 23.94 24.32 32384 20100409 FIS 24.3 24.55 24.22 24.52 16857 20100412 FIS 24.65 24.91 24.65 24.79 17115 20100413 FIS 24.79 24.92 24.53 24.67 19134 20100414 FIS 24.59 24.94 24.59 24.86 30639 20100415 FIS 24.77 25.38 24.7 25.35 23347 20100416 FIS 25.24 25.55 25.13 25.19 31267 20100419 FIS 25.1 25.19 24.9 25.16 18867 20100420 FIS 25.36 25.72 25.22 25.63 26860 20100421 FIS 25.52 25.82 25.4 25.57 20011 20100422 FIS 25.34 25.8 25.21 25.75 17210 20100423 FIS 25.79 25.88 25.26 25.76 29725 20100426 FIS 25.71 25.9 25.62 25.65 23394 20100427 FIS 25.54 25.78 25.03 25.04 27631 20100428 FIS 25.34 26.6 25.24 26.34 58522 20100429 FIS 26.45 26.74 26.26 26.73 38123 20100430 FIS 26.7 26.75 26.18 26.29 35730 20100503 FIS 26.35 26.52 26.19 26.3 28527 20100504 FIS 26.04 26.19 25.8 25.96 44225 20100505 FIS 25.86 26.11 25.84 26 28374 20100506 FIS 25.9 30.78 25.745 28.68 359786 20100507 FIS 28.53 29.22 28.28 28.76 156152 20100510 FIS 29.51 29.79 29.2 29.63 89160 20100511 FIS 29.01 29.52 28.83 28.86 55441 20100512 FIS 30.13 30.3299 29.63 29.7 147943 20100513 FIS 29.87 30.27 29.76 29.9 86569 20100514 FIS 29.83 29.99 28.35 29.69 80658 20100517 FIS 29.73 29.8 28.7 28.88 66074 20100518 FIS 27.11 27.78 26.8 27.15 179621 20100519 FIS 27.06 27.56 26.94 27.01 79987 20100520 FIS 26.75 26.8 25.5 25.81 124838 20100521 FIS 25.51 26.27 25.44 26.17 85528 20100524 FIS 26.11 26.36 25.62 26.12 53373 20100525 FIS 25.77 26.56 25.28 26.56 97838 20100526 FIS 28.14 28.23 27.36 27.47 153752 20100527 FIS 27.87 27.98 27.67 27.95 62760 20100528 FIS 27.9 27.92 27.5 27.52 37480 20100601 FIS 27.4 27.6 27.26 27.3 46811 20100602 FIS 27.42 27.58 27.16 27.56 38165 20100603 FIS 27.47 27.74 27.42 27.48 29941 20100604 FIS 27.49 27.56 27.05 27.14 61845 20100607 FIS 27.15 27.28 26.71 26.75 50496 20100608 FIS 26.74 26.98 26.48 26.88 43822 20100609 FIS 27.03 27.28 26.63 26.74 55217 20100610 FIS 26.96 27.4 26.96 27.3 33115 20100611 FIS 27.17 27.26 26.99 27.21 26311 20100614 FIS 27.41 27.46 26.97 27.04 31288 20100615 FIS 27.17 27.39 27.03 27.27 41741 20100616 FIS 27.15 27.84 27.12 27.64 60314 20100617 FIS 27.73 27.8 27.54 27.79 32339 20100618 FIS 27.84 27.85 27.47 27.48 39451 20100621 FIS 27.76 27.925 27.52 27.64 44119 20100622 FIS 27.83 28.04 27.25 27.27 31866 20100623 FIS 27.27 27.48 27.1 27.26 30393 20100624 FIS 27.17 27.43 26.98 27.14 23598 20100625 FIS 27.7 27.8 27.31 27.54 57561 20100628 FIS 27.51 27.75 27.26 27.4 18080 20100629 FIS 27.18 27.29 26.91 27.05 45236 20100630 FIS 27.01 27.35 26.78 26.82 34760 20100701 FIS 27.01 27.05 26.45 26.53 59679 20100702\n\n---\n\n195358 20100128 TXN 23.46 23.51 22.69 23.05 202002 20100129 TXN 23.11 23.37 22.28 22.5 231372 20100201 TXN 22.56 23.08 22.56 23.05 131989 20100202 TXN 22.97 23.37 22.94 23.31 118910 20100203 TXN 23.26 23.32 22.93 23.2 128825 20100204 TXN 23.01 23.01 22.4 22.59 146440 20100205 TXN 22.55 23.13 22.5 22.97 230939 20100208 TXN 23 23.37 22.7 23.1 161392 20100209 TXN 23.33 23.66 23.27 23.38 174955 20100210 TXN 23.39 23.58 23.141 23.44 124013 20100211 TXN 23.43 24 23.3 23.77 161971 20100212 TXN 23.54 24.27 23.4 24.03 217975 20100216 TXN 24.13 24.88 24.13 24.79 228568 20100217 TXN 24.86 24.97 24.3 24.71 194304 20100218 TXN 24.65 24.86 24.385 24.83 132190 20100219 TXN 24.8 25.06 24.59 25.01 159789 20100222 TXN 25.02 25.15 24.62 24.73 111767 20100223 TXN 24.68 24.72 24.06 24.3 129057 20100224 TXN 24.53 25 24.48 24.75 145146 20100225 TXN 24.21 24.55 24.01 24.52 178860 20100226 TXN 24.45 24.61 24.2275 24.38 132059 20100301 TXN 24.53 24.925 24.47 24.63 148938 20100302 TXN 24.54 24.92 24.25 24.48 168885 20100303 TXN 24.57 24.79 24.35 24.4 130126 20100304 TXN 24.46 24.75 24.16 24.67 135379 20100305 TXN 24.8 25.09 24.6075 24.97 103485 20100308 TXN 25.09 25.09 24.55 24.69 222691 20100309 TXN 24.29 24.49 23.87 24.19 279905 20100310 TXN 24.19 24.68 24.17 24.59 138785 20100311 TXN 24.38 24.4 23.8 24.07 230882 20100312 TXN 24.1 24.24 23.9 24 150738 20100315 TXN 23.91 23.99 23.7 23.94 90533 20100316 TXN 24.01 24.75 23.96 24.68 182819 20100317 TXN 24.56 25 24.56 24.91 126211 20100318 TXN 24.89 25 24.55 24.72 105019 20100319 TXN 24.72 24.73 24.13 24.36 169453 20100322 TXN 24.22 24.75 24.17 24.73 106521 20100323 TXN 24.8 25.48 24.73 25.45 179378 20100324 TXN 25.31 25.33 24.72 24.79 169292 20100325 TXN 25.16 25.22 24.78 24.79 113064 20100326 TXN 24.91 25.03 24.51 24.75 101379 20100329 TXN 24.86 25.07 24.62 24.73 92175 20100330 TXN 24.73 24.89 24.5 24.61 110744 20100331 TXN 24.58 24.7725 24.38 24.47 98998 20100401 TXN 24.64 25 24.44 24.63 90569 20100405 TXN 24.7 25.5 24.66 25.39 142257 20100406 TXN 25.25 25.3 24.93 25.05 106280 20100407 TXN 25.11 25.4 24.89 25.32 133339 20100408 TXN 25.12 25.32 24.72 24.72 160034 20100409 TXN 24.87 24.97 24.62 24.94 134514 20100412 TXN 25.26 25.98 25.24 25.69 185745 20100413 TXN 25.63 26 25.58 25.87 116066 20100414 TXN 26.41 26.91 26.38 26.9 203173 20100415 TXN 26.87 27 26.6 26.99 115712 20100416 TXN 26.73 26.81 26.35 26.58 147765 20100419 TXN 26.47 26.68 25.91 26.43 132896 20100420 TXN 26.6 26.84 26.4 26.65 110046 20100421 TXN 26.82 26.9 26.06 26.42 104803 20100422 TXN 25.95 26.6 25.4 26.5 175064 20100423 TXN 26.47 26.75 26.03 26.67 144715 20100426 TXN 26.83 27.35 26.79 27.16 210703 20100427 TXN 26.8 27.44 26.41 26.54 376491 20100428 TXN 26.74 26.76 26.0901 26.4 171882 20100429 TXN 26.635 27.05 26.36 27.01 151334 20100430 TXN 26.91 26.95 26.01 26.01 180689 20100503 TXN 26.23 26.72 26.1 26.45 129850 20100504 TXN 26.18 26.22 25.44 25.74 210862 20100505 TXN 25.53 26.18 25.191 25.87 214855 20100506 TXN 25.78 26.12 23.49 25.07 273766 20100507 TXN 24.91 25.27 23.96 24.74 264918 20100510 TXN 25.68 26 25.45 25.82 176226 20100511 TXN 25.5 26.15 25.25 25.65 158929 20100512 TXN 25.81 26.15 25.67 26.1 126989 20100513 TXN 25.98 26.09 25.41 25.49 133141 20100514 TXN 25.27 25.36 24.5 24.88 183232 20100517 TXN 24.95 25.5 24.66 25.42 164559 20100518 TXN 25.6 25.66 24.39 24.54 250473 20100519 TXN 24.43 24.87 24.1 24.65 194045 20100520 TXN 24.14 24.7 23.9 24.26 245637 20100521 TXN 23.89 24.84 23.6 24.57 192649 20100524 TXN 24.45 24.6 24.15 24.24 126525 20100525 TXN 23.62 24.44 23.45 24.4 207615 20100526 TXN 24.54 24.8201 24.04 24.14 179781 20100527 TXN 24.51 24.87 24.46 24.85 149743 20100528 TXN 24.77 24.9 24.2 24.42 145900 20100601 TXN 24.28 24.86 24.27 24.35 150996 20100602 TXN 24.52 24.78 24.238 24.76 128460 20100603 TXN 24.81 25.18 24.645 25.04 121507 20100604 TXN 24.66 24.95 24.07 24.1775 145425 20100607 TXN 24.32 24.56 23.605 23.67 168834 20100608 TXN 23.99 24 23.09 23.88 191134 20100609 TXN 24.3 24.54 23.64 23.74 198828 20100610\n\n---\n\n20100602 PFE 15.12 15.22 14.92 15.2 495486 20100603 PFE 15.24 15.34 15.12 15.2325 342474 20100604 PFE 15.01 15.04 14.67 14.755 779382 20100607 PFE 14.86 14.89 14.5 14.52 687857 20100608 PFE 14.56 14.57 14.35 14.55 632462 20100609 PFE 14.64 14.75 14.39 14.52 865832 20100610 PFE 14.65 15.11 14.65 14.91 601769 20100611 PFE 15.23 15.52 15.2 15.46 756211 20100614 PFE 15.56 15.6 15.3 15.33 512611 20100615 PFE 15.4 15.53 15.3 15.52 504777 20100616 PFE 15.42 15.57 15.36 15.48 379236 20100617 PFE 15.43 15.47 15.13 15.47 497231 20100618 PFE 15.49 15.55 15.0875 15.21 698247 20100621 PFE 15.36 15.38 15.01 15.1 457157 20100622 PFE 15.155 15.24 14.97 14.97 438489 20100623 PFE 14.98 14.98 14.81 14.88 483207 20100624 PFE 14.62 14.73 14.37 14.46 860758 20100625 PFE 14.49 14.71 14.4 14.64 586342 20100628 PFE 14.69 14.775 14.5 14.54 446228 20100629 PFE 14.42 14.48 14.18 14.28 648926 20100630 PFE 14.215 14.48 14.17 14.26 506833 20100701 PFE 14.29 14.33 14 14.23 678767 20100702 PFE 14.29 14.36 14.1 14.14 407539 20100706 PFE 14.33 14.41 14.1425 14.29 719526 20100707 PFE 14.31 14.63 14.2 14.62 542619 20100708 PFE 14.78 14.98 14.62 14.82 597926 20100709 PFE 14.85 14.86 14.63 14.77 326207 20100712 PFE 14.73 14.94 14.69 14.93 383671 20100713 PFE 15 15.1 14.76 14.79 500494 20100714 PFE 14.73 14.96 14.65 14.84 455868 20100715 PFE 14.85 14.93 14.65 14.87 436262 20100716 PFE 14.83 14.94 14.55 14.56 477874 20100719 PFE 14.62 14.84 14.58 14.73 327077 20100720 PFE 14.65 14.65 14.44 14.55 471419 20100721 PFE 14.52 14.72 14.42 14.5 422883 20100722 PFE 14.61 14.87 14.59 14.81 448142 20100723 PFE 14.75 14.8 14.39 14.58 532024 20100726 PFE 14.63 15.09 14.61 15.02 554948 20100727 PFE 15.08 15.36 14.99 15.27 606620 20100728 PFE 15.28 15.44 14.95 15 403540 20100729 PFE 15.175 15.42 15.02 15.09 585268 20100730 PFE 15.02 15.13 14.88 15 440411 20100802 PFE 15.16 15.48 15.1 15.48 547880 20100803 PFE 16 16.48 15.95 16.34 1592053 20100804 PFE 16.26 16.52 16.1175 16.44 731704 20100805 PFE 16.39 16.48 16.07 16.19 737300 20100806 PFE 16.06 16.28 16 16.24 516321 20100809 PFE 16.29 16.48 16.1063 16.42 480861 20100810 PFE 16.29 16.6 16.26 16.57 575932 20100811 PFE 16.3 16.34 15.99 16 537146 20100812 PFE 15.9 16.23 15.86 16.2 484531 20100813 PFE 16.16 16.25 16.03 16.08 324062 20100816 PFE 15.98 16.17 15.85 16.03 362828 20100817 PFE 16.23 16.4 16.1304 16.27 504657 20100819 PFE 16.07 16.13 15.82 16.03 532621 20100820 PFE 15.91 16.015 15.85 15.92 490995 20090821 PFG 26.3 28.13 26.12 27.74 47727 20090824 PFG 28.12 28.69 27.65 27.85 50478 20090825 PFG 28.11 28.86 27.93 28.04 34908 20090826 PFG 28.04 28.33 27.48 28.1 30747 20090827 PFG 27.68 28.87 27.38 28.71 31923 20090828 PFG 29.11 29.41 28.31 28.88 21923 20090831 PFG 28.35 28.47 27.85 28.4 24323 20090901 PFG 27.95 28.36 25.95 26.16 42524 20090902 PFG 25.93 26.23 25.3 25.93 44565 20090903 PFG 25.89 26.42 25.28 25.77 44533 20090904 PFG 25.79 26.27 25.56 26.06 23538 20090909 PFG 26.33 26.73 26.19 26.63 24968 20090910 PFG 26.7 28.56 26.5 28.49 41515 20090911 PFG 27.91 28.3 27.55 27.83 52971 20090914 PFG 27.36 28.03 27.07 28 31701 20090915 PFG 28.2 28.46 27.78 28.2 28410 20090916 PFG 28.4 30.87 28.2 30.83 50226 20090917 PFG 30.19 30.75 28.83 29.01 38943 20090918 PFG 29.18 29.3 28.14 28.29 42943 20090921 PFG 27.44 27.93 27.29 27.56 33078 20090922 PFG 28.03 28.29 27.5 27.76 39663 20090923 PFG 28.01 28.01 26.35 26.36 49439 20090924 PFG 26.58 26.9 25.81 26.03 32463 20090925 PFG 25.9 26.09 25.16 25.8 33777 20090928 PFG 25.92 27.99 25.75 27.97 40614 20090929 PFG 27.95 28.53 27.37 27.83 28275 20090930 PFG 27.84 28.39 26.86 27.39 35961 20091001 PFG 27.2 27.3 25.4 25.46 47228 20091002 PFG 25.11 25.81 24.3801 25.26 41000 20091005 PFG 25.51 26.68 25.3 26.64 30377 20091006 PFG 26.91 27.88 26.43 27.26 46957 20091007 PFG 27.14 27.58 26.86 27.4 26613 20091008 PFG 27.68 28.33 27.5 28.11 41339 20091009 PFG 27.87 28.37 27.69 28.29 25501 20091012 PFG 28.48 28.58 28.16 28.51 19649 20091013 PFG 28.21 28.4 27.43 27.81 21681 20091014 PFG 28.51 29.64 28.29\n\n---\n\n20.03 19.25 19.92 37648 20100301 TXT 20 20.31 19.82 20.21 44004 20100302 TXT 20.34 20.99 20.05 20.9 49482 20100303 TXT 20.92 21.45 20.76 21.24 46268 20100304 TXT 21.36 21.57 20.93 21.06 50492 20100305 TXT 21.2 21.84 21.2 21.81 45740 20100308 TXT 21.78 22.17 21.73 21.74 43337 20100309 TXT 21.13 21.96 21.01 21.62 78018 20100310 TXT 21.17 22.07 21.17 21.81 47187 20100311 TXT 21.68 22.34 21.3 22.25 39057 20100312 TXT 22.37 22.44 21.92 22.26 33746 20100315 TXT 22.17 22.2 21.61 22.05 30485 20100316 TXT 22.06 22.78 21.94 22.4 43861 20100317 TXT 22.52 22.78 22.23 22.53 30612 20100318 TXT 22.41 22.5 22 22.15 26976 20100319 TXT 22.21 22.97 22.07 22.21 56745 20100322 TXT 21.99 22.4 21.8 22.18 30576 20100323 TXT 22.28 22.47 22.07 22.45 31085 20100324 TXT 22.28 22.58 22.15 22.28 24703 20100325 TXT 22.53 22.56 21.73 21.77 49748 20100326 TXT 21.9 22.3 21.62 21.68 38683 20100329 TXT 21.84 21.95 21.49 21.7 40553 20100330 TXT 21.76 22 21.41 21.56 32409 20100331 TXT 21.48 21.59 21.18 21.23 36943 20100401 TXT 21.42 21.57 21.17 21.4 36557 20100405 TXT 21.54 21.61 21.16 21.33 49152 20100406 TXT 21.23 21.82 21.12 21.57 37554 20100407 TXT 21.45 22.27 21.25 22.18 96531 20100408 TXT 22.11 22.25 21.91 22.17 38680 20100409 TXT 22.23 22.3 21.67 22.09 31193 20100412 TXT 22.1 22.66 22.06 22.59 38606 20100413 TXT 22.49 22.66 22.37 22.55 32789 20100414 TXT 22.64 22.78 22.24 22.76 43751 20100415 TXT 22.48 22.71 22.27 22.33 48089 20100416 TXT 22.42 22.43 21.61 21.94 56083 20100419 TXT 21.75 21.89 21.09 21.56 40196 20100420 TXT 21.67 22 21.5 21.87 30741 20100421 TXT 21.66 22.17 21.58 21.6 56747 20100422 TXT 22.18 24.36 21.99 24.23 164175 20100423 TXT 24.31 24.33 23.48 23.85 69210 20100426 TXT 23.94 25.3 23.92 24.55 77962 20100427 TXT 24.45 24.45 23.12 23.25 74654 20100428 TXT 23.41 23.96 23.22 23.61 45612 20100429 TXT 23.91 24.2 23.44 23.52 32942 20100430 TXT 23.5 23.72 22.84 22.84 36452 20100503 TXT 23 23.55 22.94 23.49 44525 20100504 TXT 23.01 23.45 22.7 22.93 59970 20100505 TXT 22.59 23.36 22.11 23.27 68902 20100506 TXT 23.14 23.79 20 22.5 77772 20100507 TXT 22.49 22.49 20.22 20.38 157695 20100510 TXT 22.01 22.56 21.75 22.39 63241 20100511 TXT 21.63 23 21.63 22.64 56401 20100512 TXT 22.89 24.2 22.89 24.09 57260 20100513 TXT 24.04 24.08 23.39 23.53 28504 20100514 TXT 23.25 23.44 22.31 22.57 48405 20100517 TXT 22.55 22.9 21.38 21.95 73374 20100518 TXT 23.06 23.06 21.41 21.5 64976 20100519 TXT 21.29 21.59 20.63 21.07 48904 20100520 TXT 20.21 20.44 19.32 19.41 85643 20100521 TXT 19.04 20.76 18.89 20.57 106973 20100524 TXT 20.43 21.01 20.19 20.22 44856 20100525 TXT 19.21 19.76 18.89 19.52 113330 20100526 TXT 19.74 21.05 19.72 20.27 111000 20100527 TXT 21.03 21.28 20.64 21.26 42259 20100528 TXT 21.26 21.34 20.45 20.67 29001 20100601 TXT 20.11 20.68 19.87 19.89 44487 20100602 TXT 20.08 20.48 19.87 20.47 35835 20100603 TXT 20.57 20.85 20.22 20.65 35770 20100604 TXT 20.28 20.46 18.81 18.96 81034 20100607 TXT 19 19.04 18.15 18.21 60477 20100608 TXT 18.17 18.96 17.98 18.96 74831 20100609 TXT 19.07 19.34 18.53 18.68 59965 20100610 TXT 19.18 19.44 18.96 19.3 48065 20100611 TXT 18.96 19.51 18.96 19.46 33417 20100614 TXT 19.56 19.94 19.24 19.3 29404 20100615 TXT 19.61 20.28 19.55 20.24 36524 20100616 TXT 20.04 20.38 19.9 20.02 41014 20100617 TXT 20.15 20.16 19.56 19.95 28188 20100618 TXT 20 20.17 19.834 20.03 27147 20100621 TXT 20.5 20.65 19.9 20.01 31035 20100622 TXT 20.16 20.24 19.24 19.35 30431 20100623 TXT 19.35 19.38 18.82 19.02 47518 20100624 TXT 18.92 19.14 18.52 18.59 47043 20100625 TXT 18.72 19.31 18.57 19.31 73939 20100628 TXT 19.32 19.41 18.62 18.66 51878 20100629 TXT 18.25 18.28 16.71 16.8 143435 20100630 TXT 16.58 17.335 16.58 16.97 72412 20100701 TXT 16.87 17 16.1 16.37 109536 20100702 TXT 16.45 16.5 15.88 16.07 60701 20100706 TXT 16.41 16.74 16.02 16.28 60671 20100707 TXT 16.31 17.18 16.23 17.17 68334 20100708 TXT 17.12 17.3 16.66 17.04 50855 20100709 TXT 17.07 17.89 17.05 17.8 54789 20100712 TXT 17.8 18.03 17.48 17.68 39380 20100713 TXT 18.41 18.9 18.2 18.39\n\n---\n\n25421 20100127 SAI 18.28 18.34 18.19 18.27 32181 20100128 SAI 18.28 18.43 18.16 18.29 27537 20100129 SAI 18.33 18.5 18.23 18.33 34509 20100201 SAI 18.28 18.62 18.11 18.6 35129 20100202 SAI 18.59 18.64 18.39 18.64 42698 20100203 SAI 18.57 18.69 18.5 18.53 35039 20100204 SAI 18.38 18.62 18.38 18.48 53648 20100205 SAI 18.47 18.68 18.37 18.68 61950 20100208 SAI 18.65 18.67 18.34 18.35 26006 20100209 SAI 18.57 18.57 18.26 18.51 25320 20100210 SAI 18.44 18.57 18.38 18.56 31906 20100211 SAI 18.59 18.67 18.36 18.66 23536 20100212 SAI 18.56 18.77 18.44 18.75 26292 20100216 SAI 18.8 19.1 18.72 19 32021 20100217 SAI 19.05 19.18 18.97 19.17 26044 20100218 SAI 19.15 19.24 19.04 19.06 24999 20100219 SAI 18.99 19.14 18.82 19.11 34400 20100222 SAI 19.11 19.2 18.96 19.01 14752 20100223 SAI 18.95 19.08 18.92 19.07 30027 20100224 SAI 19.14 19.48 19.07 19.48 41439 20100225 SAI 19.25 19.43 19.06 19.39 30501 20100226 SAI 19.45 19.75 19.44 19.7 162914 20100301 SAI 19.7 19.76 19.47 19.51 26636 20100302 SAI 19.67 19.7 19.28 19.41 41877 20100303 SAI 19.49 19.49 19.2 19.22 34553 20100304 SAI 19.36 19.45 19.15 19.2 33913 20100305 SAI 19.3 19.42 19.19 19.31 34397 20100308 SAI 19.33 19.37 19.24 19.33 31140 20100309 SAI 19.28 19.51 19.27 19.49 30677 20100310 SAI 19.48 19.5 19.34 19.47 24065 20100311 SAI 19.4 19.43 19.26 19.39 25510 20100312 SAI 19.4 19.43 19.25 19.3 15151 20100315 SAI 19.3 19.35 19.21 19.35 16853 20100316 SAI 19.3 19.33 19.22 19.32 16970 20100317 SAI 19.3 19.39 19.23 19.27 21840 20100318 SAI 19.21 19.34 19.06 19.14 28238 20100319 SAI 19.16 19.18 18.78 19.14 52677 20100322 SAI 19.07 19.48 18.98 19.43 29113 20100323 SAI 19.4 19.48 19.14 19.24 27853 20100324 SAI 19.22 19.28 19.04 19.05 18731 20100325 SAI 19.12 19.22 19.08 19.1 15765 20100326 SAI 19.17 19.31 19.07 19.26 24784 20100329 SAI 19.35 19.35 18.9 18.91 33623 20100330 SAI 18.97 19.06 18.82 18.98 36347 20100331 SAI 17.86 18.1 17.5 17.7 157248 20100401 SAI 17.7 17.8 17.32 17.42 80600 20100405 SAI 17.49 17.55 17.36 17.42 44256 20100406 SAI 17.41 17.47 17.16 17.3 39445 20100407 SAI 17.34 17.34 16.99 17.2 59865 20100408 SAI 17.15 17.23 17.05 17.2 34529 20100409 SAI 17.29 17.57 17.22 17.51 46585 20100412 SAI 17.66 17.66 17.34 17.4 48532 20100413 SAI 17.41 17.58 17.31 17.5 37805 20100414 SAI 17.51 17.74 17.48 17.72 45872 20100415 SAI 17.92 18.14 17.72 18 69106 20100416 SAI 17.94 18.005 17.66 17.97 68437 20100419 SAI 18.01 18.21 17.91 18.19 53966 20100420 SAI 17.97 18.3 17.83 18.29 60218 20100421 SAI 18.21 18.35 18.14 18.26 47815 20100422 SAI 18.2 18.39 18.04 18.36 46414 20100423 SAI 18.36 18.46 18.18 18.46 39503 20100426 SAI 18.36 18.42 18.1899 18.22 50373 20100427 SAI 18.15 18.21 17.99 18.01 51396 20100428 SAI 18.11 18.11 17.58 17.73 44267 20100429 SAI 17.74 17.84 17.67 17.73 25016 20100430 SAI 17.77 17.8 17.34 17.41 63264 20100503 SAI 17.49 17.57 17.37 17.44 32041 20100504 SAI 17.31 17.5 17.21 17.46 34072 20100505 SAI 17.42 17.85 17.34 17.43 23353 20100506 SAI 17.36 17.69 17.07 17.29 52925 20100507 SAI 17.28 17.62 17.22 17.54 80882 20100510 SAI 17.87 17.87 17.31 17.43 47543 20100511 SAI 17.31 17.4 16.98 17.15 78147 20100512 SAI 17.22 17.26 17.13 17.25 41221 20100513 SAI 17.24 17.34 17.17 17.21 24229 20100514 SAI 17.21 17.42 17.06 17.22 39474 20100517 SAI 17.2 17.63 17.2 17.58 45600 20100518 SAI 17.59 17.695 17.49 17.53 51116 20100519 SAI 17.43 17.59 17.3 17.34 42237 20100520 SAI 17.14 17.27 16.9 16.9 43867 20100521 SAI 16.74 17.17 16.65 17.16 51934 20100524 SAI 17.02 17.24 17 17.13 24121 20100525 SAI 16.93 17.14 16.71 17.12 38161 20100526 SAI 17.2 17.33 16.97 17.03 37954 20100527 SAI 17.23 17.29 17.01 17.25 20276 20100528 SAI 17.24 17.31 17.1 17.19 21695 20100601 SAI 17.12 17.26 16.95 17.07 21969 20100602 SAI 17.11 17.44 17.0399 17.44 22056 20100603 SAI 17.31 17.79 17.31 17.62 31358 20100604 SAI 17.55 17.95 17.37 17.58 57694 20100607 SAI 17.65 17.75 17.4 17.49 35298 20100608 SAI 17.53 17.53 17.28 17.39 44461 20100609 SAI 17.41 17.59 17.34 17.4 35663 20100610 SAI 17.5 17.85 17.5 17.69 45181\n\n---\n\n109956 20100803 MI 7.44 7.48 7.29 7.33 66131 20100804 MI 7.34 7.37 7.01 7.17 78494 20100805 MI 7.12 7.27 7.05 7.24 51431 20100806 MI 7.11 7.15 6.96 7.14 42269 20100809 MI 7.27 7.27 6.92 7.07 76150 20100810 MI 6.95 7.07 6.9 6.98 57744 20100811 MI 6.81 6.85 6.56 6.61 78995 20100812 MI 6.56 6.73 6.45 6.67 112671 20100813 MI 6.68 6.87 6.62 6.7 59285 20100816 MI 6.64 6.64 6.37 6.56 82597 20100817 MI 6.69 6.72 6.47 6.5 87262 20100819 MI 6.43 6.52 6.17 6.27 90869 20100820 MI 6.21 6.41 6.17 6.36 83007 20090821 MIL 67.88 68.17 67.54 67.93 5333 20090824 MIL 67.7 67.79 66.87 67.17 3409 20090825 MIL 67.31 67.38 66.65 66.81 3552 20090826 MIL 66.71 67.112 66.57 66.77 4027 20090827 MIL 66.72 67.0599 65.92 66.97 3215 20090828 MIL 67.27 67.75 66.42 66.79 3598 20090831 MIL 66.48 66.98 65.78 66.23 3461 20090901 MIL 66.18 66.97 64.91 65.37 5180 20090902 MIL 65.05 65.55 64.71 65.38 4638 20090903 MIL 65.39 65.7 64.78 65.24 6166 20090904 MIL 65.16 66.25 64.92 66.25 6221 20090909 MIL 67.75 69.28 67.05 69.17 7596 20090910 MIL 69.28 69.29 68.48 68.71 4816 20090911 MIL 68.8 69.73 68.41 69.44 3383 20090914 MIL 69.08 70.4596 69.08 70.26 4250 20090915 MIL 70.25 70.25 68.65 69.46 5164 20090916 MIL 69.71 71.41 69.45 71.41 6061 20090917 MIL 71.12 71.85 70.66 71.62 5360 20090918 MIL 70.3 72.65 70.3 72.43 7074 20090921 MIL 71.97 72.33 71.27 71.37 4664 20090922 MIL 71.59 71.64 70.6 71.1 2891 20090923 MIL 71.13 71.19 70.12 70.15 3412 20090924 MIL 70.25 70.29 69.48 69.63 3366 20090925 MIL 69.27 69.98 69.17 69.77 2703 20090928 MIL 69.91 70.41 69.47 69.82 2637 20090929 MIL 70.19 71.1 69.76 70.95 3540 20090930 MIL 70.66 71.03 69.26 70.33 4079 20091001 MIL 69.91 70.53 69.52 69.52 4006 20091002 MIL 69.22 69.51 68.42 68.68 4527 20091005 MIL 68.95 70.08 68.37 70.08 3784 20091006 MIL 70 71.1 69.4555 70.83 3447 20091007 MIL 70.55 70.73 70.01 70.53 2548 20091008 MIL 70.8 71.09 70.42 70.58 3782 20091009 MIL 70.6 71.13 70.32 70.77 4307 20091012 MIL 70.79 71.67 70.66 71.56 3343 20091013 MIL 71.44 71.79 70.48 70.86 4407 20091014 MIL 71.38 72.19 70.99 72.19 7756 20091015 MIL 72.19 72.59 71.65 72.25 5641 20091016 MIL 72.14 72.14 71.31 71.62 2628 20091019 MIL 71.76 72.69 71.35 72.66 2938 20091020 MIL 72.61 72.61 71.5 71.69 4088 20091021 MIL 71.75 72.39 71.42 71.81 3271 20091022 MIL 71.78 71.78 70.81 71 6757 20091023 MIL 70.95 71.08 70.31 70.75 4125 20091026 MIL 70.5 70.84 69.24 69.42 4514 20091027 MIL 69.35 70.31 69.25 69.84 5740 20091028 MIL 70.02 70.02 68.06 68.11 5032 20091105 MIL 68.41 69.55 68.34 68.75 4657 20091106 MIL 67.3 68.95 66.98 67.66 12010 20091109 MIL 68.06 68.72 67.532 68.7 4445 20091110 MIL 68.73 69.23 68.62 69.06 4305 20091111 MIL 69 69.7375 68.57 68.69 3078 20091112 MIL 68.44 68.94 67.76 68.1 2764 20091113 MIL 68.07 68.63 67.65 68.41 2234 20091116 MIL 68.44 68.68 68.14 68.54 4822 20091117 MIL 68.53 68.74 68.13 68.6 4251 20091118 MIL 68.51 68.58 67.4 67.76 4149 20091119 MIL 67.66 68.17 67.13 67.95 3524 20091120 MIL 67.67 67.95 67.52 67.73 6560 20091123 MIL 67.97 68.85 67.97 68.3 3116 20091124 MIL 68.14 68.73 67.87 68.56 3020 20091125 MIL 68.44 68.59 67.94 68.27 5982 20091127 MIL 67.21 68.16 66.65 67.85 2250 20091130 MIL 67.99 68.15 67.5 68.1 3187 20091201 MIL 68.43 69.13 68.05 68.94 3482 20091202 MIL 68.78 69.98 68.78 69.77 4478 20091203 MIL 69.71 70.45 69.47 69.54 4471 20091204 MIL 70.04 70.67 69.78 70.43 5166 20091207 MIL 69.98 70.61 69.88 69.97 2991 20091208 MIL 69.79 70.03 69.13 69.72 2934 20091209 MIL 69.68 69.71 68.7 69.51 2804 20091210 MIL 69.7 70.93 69.52 70.37 2613 20091211 MIL 70.57 70.68 69.73 70.23 2874 20091214 MIL 70.56 71.28 70.44 71.03 3827 20091215 MIL 70.96 71.69 70.79 71.51 6502 20091216 MIL 71.48 72.41 71.27 71.76 4475 20091217 MIL 71.61 71.67 71.06 71.21 2284 20091218 MIL 71.15 71.65 70.08 71.12 4105 20091221 MIL 71.4 72.03 71.1701 71.57 1263 20091222 MIL 71.56 72.34 71.56 72.14 1962 20091223 MIL 72.13 72.66 71.87 72.56 1881 20091224 MIL 72.5 72.63 72.16 72.5 478 20091228 MIL 72.5 72.72 72.34 72.69 934 20091229 MIL 72.72 73.02 72.39 72.68\n\n---\n\n115183 20100408 DHI 11.9 12.03 11.75 12.01 79148 20100409 DHI 12.04 12.185 11.98 12.14 38701 20100412 DHI 12.19 12.24 11.89 12.03 67469 20100413 DHI 12.04 12.27 12.01 12.18 69399 20100414 DHI 12.25 12.81 12.24 12.65 101835 20100415 DHI 12.63 12.74 12.51 12.6 56106 20100416 DHI 12.5 12.58 12.025 12.37 93481 20100419 DHI 12.32 12.4 12.04 12.34 48289 20100420 DHI 12.41 12.79 12.255 12.76 59225 20100421 DHI 12.77 13.1 12.65 12.98 63332 20100422 DHI 12.92 13.855 12.77 13.69 112278 20100423 DHI 13.79 14.54 13.72 14.17 123148 20100426 DHI 14.23 14.48 13.81 13.88 63999 20100427 DHI 13.75 14.03 13.37 13.41 91512 20100428 DHI 13.48 50.8 13.47 13.62 74409 20100429 DHI 13.75 14.42 13.63 14.24 111553 20100430 DHI 15.07 15.44 14.63 14.69 154285 20100503 DHI 14.71 15.2 14.64 14.97 70491 20100504 DHI 14.75 14.82 14.22 14.63 86924 20100505 DHI 14.4 14.62 14.03 14.14 77508 20100506 DHI 14 14.38 12.64 13.65 108580 20100507 DHI 13.68 13.87 12.92 13.06 99551 20100510 DHI 13.67 14.01 13.37 13.94 81169 20100511 DHI 13.68 14.38 13.54 13.84 89447 20100512 DHI 13.93 14.18 13.82 14.04 50532 20100513 DHI 14.02 14.02 13.33 13.46 72709 20100514 DHI 13.29 13.34 12.81 13.11 69260 20100517 DHI 13.08 13.32 12.62 13.3 75588 20100518 DHI 13.42 13.75 12.96 13.02 76647 20100519 DHI 12.81 13.3 12.38 12.67 141218 20100520 DHI 12.29 12.56 12.13 12.14 110594 20100521 DHI 12.02 12.4684 11.86 12.26 109993 20100524 DHI 12.19 12.57 12.05 12.06 64159 20100525 DHI 11.67 12.14 11.57 12.1 104797 20100526 DHI 12.43 12.67 11.97 12.01 95058 20100527 DHI 12.25 12.35 11.92 12.34 58922 20100528 DHI 12.32 12.48 12.12 12.19 48966 20100601 DHI 12.1 12.29 11.76 11.77 75995 20100602 DHI 11.78 12.16 11.75 12.13 64535 20100603 DHI 12.13 12.21 11.69 11.78 78210 20100604 DHI 11.6 11.68 11.25 11.34 72681 20100607 DHI 11.39 11.46 10.82 10.89 64236 20100608 DHI 10.92 11.05 10.44 10.84 131892 20100609 DHI 11.08 11.1 10.46 10.54 110135 20100610 DHI 10.79 11.41 10.6392 11.3 138522 20100611 DHI 11.15 11.28 10.97 11.26 63014 20100614 DHI 11.35 11.41 10.99 11.07 67270 20100615 DHI 11.16 11.39 11.07 11.39 72290 20100616 DHI 11.22 11.49 11.07 11.24 77644 20100617 DHI 11.19 11.22 10.63 10.94 82669 20100618 DHI 10.92 10.96 10.66 10.75 59399 20100621 DHI 10.9 10.99 10.48 10.54 75845 20100622 DHI 10.52 10.67 10.16 10.22 81665 20100623 DHI 10.22 10.6 10.03 10.47 85873 20100624 DHI 10.48 10.76 10.29 10.58 101041 20100625 DHI 10.57 10.57 10.26 10.47 71931 20100628 DHI 10.5 10.59 10.29 10.36 86558 20100629 DHI 10.3 10.39 9.85 9.96 95902 20100630 DHI 9.96 10.15 9.82 9.83 92595 20100701 DHI 9.78 10 9.58 9.85 118264 20100702 DHI 9.89 9.89 9.41 9.71 95166 20100706 DHI 9.88 10.05 9.7 9.79 110932 20100707 DHI 9.8 10.23 9.775 10.2 83742 20100708 DHI 10.29 10.42 9.74 9.8 166530 20100709 DHI 9.81 10.35 9.78 10.25 61343 20100712 DHI 10.23 10.27 9.98 10.1 38194 20100713 DHI 10.17 10.5 10.1075 10.43 65541 20100714 DHI 10.33 10.36 10.06 10.34 66239 20100715 DHI 10.35 10.69 10.2 10.62 103381 20100716 DHI 10.55 10.57 10.03 10.1 74508 20100719 DHI 10.17 10.21 9.85 9.97 65190 20100720 DHI 9.8 10.48 9.72 10.39 61981 20100721 DHI 10.51 10.54 10.15 10.2 60966 20100722 DHI 10.33 10.74 10.31 10.55 53182 20100723 DHI 10.5 10.9 10.41 10.85 54987 20100726 DHI 10.82 11.2701 10.76 11.17 79047 20100727 DHI 11.24 11.38 11.01 11.08 84495 20100728 DHI 11.07 11.14 10.55 10.64 51520 20100729 DHI 10.76 11.01 10.5775 10.88 83513 20100730 DHI 10.74 11.09 10.61 11.02 73305 20100802 DHI 11.22 11.38 10.94 11.25 70449 20100803 DHI 11.09 11.3 10.48 10.6 122024 20100804 DHI 10.65 10.82 10.46 10.48 46427 20100805 DHI 10.31 10.53 10.28 10.42 45848 20100806 DHI 10.33 10.66 10.24 10.6 55464 20100809 DHI 10.9 11.14 10.76 11.06 61510 20100810 DHI 10.9 10.98 10.72 10.83 48069 20100811 DHI 10.61 10.67 10.46 10.54 57940 20100812 DHI 10.27 10.47 10.185 10.21 44969 20100813 DHI 10.18 10.38 10.13 10.24 45157 20100816 DHI 10.15 10.34 10.085 10.18 31624 20100817 DHI 10.31 10.58 10.19 10.47 41535 20100819 DHI 10.56 10.58 10.34 10.43 43980 20100820 DHI 10.32 10.39\n\n---\n\n10.52 53636 20091109 GCI 10.71 11.17 10.69 11.16 58843 20091110 GCI 11.26 11.41 10.85 11.12 55264 20091111 GCI 11.38 11.49 10.99 11.23 46486 20091112 GCI 11.18 11.39 10.69 10.75 71831 20091113 GCI 10.88 11.08 10.734 10.8 64764 20091116 GCI 10.86 11.53 10.81 11.5 51858 20091117 GCI 11.49 11.58 11.17 11.41 47613 20091118 GCI 11.41 11.5 11.21 11.47 46623 20091119 GCI 11.34 11.34 10.8 10.89 37494 20091120 GCI 10.74 10.83 10.33 10.38 43022 20091123 GCI 10.7 11.02 10.44 10.47 56596 20091124 GCI 10.55 10.645 10.34 10.45 37222 20091125 GCI 10.44 10.79 10.42 10.62 27077 20091127 GCI 10.07 10.445 9.8 10.32 19210 20091130 GCI 10.26 10.38 9.72 9.89 109242 20091201 GCI 10.05 10.18 9.68 10.01 66807 20091202 GCI 10.04 10.09 9.63 9.87 69627 20091203 GCI 9.94 10.2 9.83 9.85 53167 20091204 GCI 10.19 10.35 9.75 10.29 69043 20091207 GCI 10.26 11.09 10.26 11.09 86784 20091208 GCI 11.05 12 11.02 11.8 180270 20091209 GCI 11.79 12.22 11.45 12 97350 20091210 GCI 12.02 13.34 12.02 12.84 148605 20091211 GCI 12.81 13.29 12.71 13.16 79161 20091214 GCI 13.4 14.15 13.4 13.83 93756 20091215 GCI 13.81 14.07 13.76 13.9 64457 20091216 GCI 13.95 14.14 13.73 13.9 87184 20091217 GCI 13.8 14.38 13.6 14.15 76069 20091218 GCI 14.33 14.42 13.8216 13.98 55544 20091221 GCI 14.14 14.25 13.9375 14.03 86451 20091222 GCI 13.93 14.41 13.85 14.41 56625 20091223 GCI 14.76 15.49 14.75 15.42 108637 20091224 GCI 15.43 15.75 15.43 15.63 23133 20091228 GCI 15.7 15.99 15.11 15.23 37212 20091229 GCI 15.3 15.54 15 15.06 32033 20091230 GCI 14.96 15.02 14.8 15.02 38629 20091231 GCI 15 15.15 14.81 14.85 21593 20100104 GCI 14.97 15.67 14.76 15.35 84904 20100105 GCI 15.4 16.39 15.16 16.24 91946 20100106 GCI 16.17 16.695 16.11 16.43 57131 20100107 GCI 16.3 16.9 16.3 16.88 60486 20100108 GCI 16.73 16.94 16.6 16.76 53499 20100111 GCI 16.78 17.33 16.665 17.25 63076 20100112 GCI 17 17.17 16.22 16.4 84332 20100113 GCI 16.42 16.72 15.74 16.45 43085 20100114 GCI 16.36 16.59 16.17 16.22 42540 20100115 GCI 16.22 16.4 15.37 16.1 73461 20100119 GCI 16.09 16.72 16.04 16.31 52365 20100120 GCI 16.11 16.24 15.75 15.96 55061 20100121 GCI 15.97 16.34 15.585 15.71 57141 20100122 GCI 15.64 16.14 15.32 15.42 58761 20100125 GCI 15.55 16.13 15.55 16.04 54054 20100126 GCI 15.97 16.27 15.74 15.84 55859 20100127 GCI 16.2 16.99 15.5746 16.14 58013 20100128 GCI 16.24 16.36 15.6 16.24 68334 20100129 GCI 16.36 16.78 15.91 16.15 101551 20100201 GCI 15.29 15.43 14.12 15.02 226283 20100202 GCI 15 15.33 14.87 15.08 83530 20100203 GCI 15.03 15.38 14.56 14.61 66050 20100204 GCI 14.13 14.23 13.4 13.66 108926 20100205 GCI 13.77 13.8 12.77 13.53 84973 20100208 GCI 13.53 13.87 13.14 13.68 72360 20100209 GCI 13.72 14.42 13.72 13.97 76831 20100210 GCI 14 14.3 13.6 13.91 49941 20100211 GCI 13.92 14.29 13.74 14.21 40428 20100212 GCI 13.98 14.38 13.75 14.29 54595 20100216 GCI 14.31 14.88 14.27 14.8 44696 20100217 GCI 14.81 15.07 14.79 14.95 42212 20100218 GCI 14.92 15.41 14.82 15.27 44087 20100219 GCI 15.19 15.5 15.11 15.34 41790 20100222 GCI 15.36 15.43 14.8 14.96 37286 20100223 GCI 14.91 15.11 14.69 14.8 35911 20100224 GCI 14.9 15.01 14.75 15 31657 20100225 GCI 14.75 15.35 14.55 15.32 48959 20100226 GCI 15.32 15.5 15.01 15.15 62473 20100301 GCI 15.22 16.04 15.22 15.93 43014 20100302 GCI 15.94 16.18 15.85 15.95 33268 20100303 GCI 16.06 16.34 15.95 16.07 37700 20100304 GCI 16.14 16.25 15.725 16.07 32574 20100305 GCI 16.22 16.39 16.075 16.27 50969 20100308 GCI 16.3 16.38 16.15 16.16 26830 20100309 GCI 16.12 16.21 15.92 16.06 30298 20100310 GCI 16.01 16.365 15.97 16.08 25871 20100311 GCI 15.97 16.32 15.88 16.29 20281 20100312 GCI 16.39 16.43 15.78 15.9 34954 20100315 GCI 15.57 16.12 15.57 16.06 35023 20100316 GCI 16.02 16.63 16.02 16.42 48410 20100317 GCI 16.48 16.84 16.4 16.78 41899 20100318 GCI 16.69 16.84 16.215 16.4 61385 20100319 GCI 16.51 16.64 16.05 16.06 81022 20100322 GCI 16.01 16.49 15.74 16.42 38887 20100323 GCI 16.49 16.8 16.19 16.72 30814 20100324 GCI 16.59 16.64 16.29 16.55 32863 20100325 GCI 16.62 16.96 16.47 16.5 33481\n\n---\n\n27.83 27.59 27.73 4771 20100114 FII 27.71 27.71 27.3002 27.5 5040 20100115 FII 27.43 27.55 27.22 27.3 7268 20100119 FII 27.4 27.76 27.25 27.75 6077 20100120 FII 27.44 27.62 27.21 27.48 6555 20100121 FII 27.56 27.66 26.88 26.88 10241 20100122 FII 26.91 26.91 25.73 25.74 14459 20100125 FII 25.97 26.49 25.83 25.98 11494 20100126 FII 25.89 26.09 25.56 25.59 11167 20100127 FII 25.59 26.67 25.52 26.5 17662 20100128 FII 26.6 26.78 25.78 26.02 14988 20100129 FII 25.62 26.06 24.87 25.38 49417 20100201 FII 25.44 26.17 25.15 26.13 24741 20100202 FII 26.05 26.73 26 26.7 24312 20100203 FII 25.28 25.29 24.59 24.63 26715 20100204 FII 24.51 24.82 23.92 24.3 29017 20100205 FII 24.35 24.75 24.05 24.65 17862 20100208 FII 24.71 24.71 23.9401 23.98 14975 20100209 FII 24.14 24.32 23.85 24.16 15197 20100210 FII 24.07 25 24.03 24.62 13832 20100211 FII 24.58 24.66 24.2 24.57 9726 20100212 FII 24.44 24.56 24.29 24.53 9574 20100216 FII 24.66 25.44 24.57 25.41 17468 20100217 FII 25.67 25.67 25.2 25.32 10075 20100218 FII 25.36 25.71 25.26 25.55 13536 20100219 FII 25.45 26.01 25.4 25.81 18718 20100222 FII 25.96 25.96 25.59 25.74 10300 20100223 FII 25.74 25.81 25.16 25.21 15194 20100224 FII 25.34 25.485 25.22 25.4 8967 20100225 FII 25.15 25.24 24.87 25.19 11435 20100226 FII 25.33 25.33 24.79 25.01 14397 20100301 FII 25.02 25.19 24.94 25.1 14522 20100302 FII 25.24 25.4 25.07 25.34 9326 20100303 FII 25.4 25.79 25.37 25.48 12870 20100304 FII 25.41 25.79 25.36 25.74 9764 20100305 FII 25.87 26.13 25.75 25.98 9363 20100308 FII 26.02 26.1 25.83 25.88 9738 20100309 FII 25.7 26.16 25.6 25.98 14676 20100310 FII 25.97 26.105 25.89 26.03 11836 20100311 FII 25.88 26.29 25.745 26.26 11157 20100312 FII 26.35 26.42 25.94 26.19 7736 20100315 FII 26.15 26.17 25.78 25.94 6718 20100316 FII 26.06 26.14 25.76 25.85 8677 20100317 FII 25.97 26.47 25.96 26.32 14320 20100318 FII 26.4 26.52 26.25 26.38 10376 20100319 FII 26.43 26.58 25.77 25.81 12240 20100322 FII 25.69 26.06 25.61 26.05 5717 20100323 FII 26.06 26.23 25.97 26.22 6382 20100324 FII 26.05 26.25 25.911 26.17 9000 20100325 FII 26.4 26.5 26.16 26.25 15618 20100326 FII 26.31 26.37 26.105 26.32 8730 20100329 FII 26.38 26.44 26.11 26.23 5731 20100330 FII 26.21 26.37 26.11 26.29 5215 20100331 FII 26.23 26.83 26.12 26.38 13526 20100401 FII 26.58 26.78 26.26 26.47 9573 20100405 FII 26.54 26.69 26.26 26.66 9840 20100406 FII 26.52 26.94 26.25 26.78 10235 20100407 FII 26.78 26.78 26.37 26.52 13322 20100408 FII 26.45 26.49 26.25 26.46 8706 20100409 FII 26.47 26.57 26.31 26.48 7884 20100412 FII 26.49 26.54 26.27 26.36 9899 20100413 FII 26.31 26.83 26.31 26.82 11081 20100414 FII 27.1 27.32 26.82 26.95 10044 20100415 FII 26.96 27.3 26.85 27.26 8610 20100416 FII 27.21 27.22 26.34 26.76 14921 20100419 FII 26.57 26.92 26.44 26.76 8829 20100420 FII 26.93 26.94 26.245 26.66 10129 20100421 FII 26.59 26.76 26.46 26.62 11702 20100422 FII 26.32 26.5 26.13 26.39 23898 20100423 FII 26.25 26.25 25.46 25.9 29989 20100426 FII 25.79 25.91 25.22 25.22 20988 20100427 FII 25.02 25.0299 24.18 24.18 30407 20100428 FII 24.4 24.6 23.95 24.25 29624 20100429 FII 24.49 24.77 24.39 24.66 22235 20100430 FII 24.63 24.83 24.11 24.12 22598 20100503 FII 24.4 24.56 24.22 24.44 20771 20100504 FII 24.12 24.18 23.81 24 23218 20100505 FII 23.49 24.17 23.33 23.87 21623 20100506 FII 23.67 23.98 22.56 23.55 39433 20100507 FII 23.48 24.18 23.28 23.53 40715 20100510 FII 24.44 24.74 23.45 23.81 33052 20100511 FII 23.6 23.74 23.35 23.5 20202 20100512 FII 23.56 23.86 23.53 23.82 14186 20100513 FII 23.72 23.86 23.435 23.44 11646 20100514 FII 23.31 23.575 23 23.16 21848 20100517 FII 23.19 23.5 22.91 23.29 13004 20100518 FII 23.52 23.53 22.71 22.81 18478 20100519 FII 22.68 23.21 22.4 23.11 21893 20100520 FII 22.77 23.01 22.28 22.28 21301 20100521 FII 21.99 22.81 21.83 22.65 21337 20100524 FII 22.81 23.04 22.4 22.4 17874 20100525 FII 21.91 22.55 21.8 22.51 20575 20100526 FII 22.68 22.83 22.27 22.38 16335 20100527 FII 22.72 22.77 22.27 22.73 19763 20100528 FII 22.61 22.69 22.1 22.21\n\n---\n\n23.08 64605 20100225 SBUX 22.64 22.98 22.43 22.9 93118 20100226 SBUX 22.87 22.99 22.68 22.91 60499 20100301 SBUX 22.94 23.34 22.91 23.29 63517 20100302 SBUX 23.28 23.4 23.08 23.33 85610 20100303 SBUX 23.29 23.38 22.94 23.06 55174 20100304 SBUX 23.09 23.17 22.87 22.92 64462 20100305 SBUX 23.01 23.39 22.87 23.37 61643 20100308 SBUX 23.26 23.59 23.25 23.32 44985 20100309 SBUX 23.2 23.75 23.2 23.62 66785 20100310 SBUX 23.56 24.27 23.51 24.23 122328 20100311 SBUX 24.09 24.67 24.04 24.27 89894 20100312 SBUX 24.43 24.48 24.14 24.28 64166 20100315 SBUX 24.34 24.5 24.24 24.42 59208 20100316 SBUX 24.87 25.37 24.86 25.29 169040 20100317 SBUX 25.26 25.66 25.13 25.56 106829 20100318 SBUX 25.45 25.5 24.97 25.02 107083 20100319 SBUX 24.97 25.15 24.75 24.97 110192 20100322 SBUX 24.74 25.38 24.35 25.24 81647 20100323 SBUX 25.26 25.43 24.95 25.41 88279 20100324 SBUX 25.89 26 25.24 25.29 121490 20100325 SBUX 25.06 25.13 24.15 24.21 189824 20100326 SBUX 24.4 24.83 24.39 24.59 102317 20100329 SBUX 24.7 24.77 24.2899 24.61 68593 20100330 SBUX 24.43 24.63 24.24 24.56 63930 20100331 SBUX 24.5 24.54 24.2 24.27 75442 20100401 SBUX 24.4 24.73 23.95 24.24 77755 20100405 SBUX 24.16 24.78 24.11 24.61 78828 20100406 SBUX 24.44 24.7 24.35 24.6 57945 20100407 SBUX 24.77 25.025 24.69 24.91 84059 20100408 SBUX 24.76 25 24.63 24.83 71673 20100409 SBUX 24.93 24.95 24.45 24.72 61909 20100412 SBUX 24.7 24.79 24.32 24.49 63051 20100413 SBUX 24.44 24.8 24.32 24.73 73523 20100414 SBUX 24.71 24.85 24.4 24.84 78828 20100415 SBUX 24.76 25.25 24.62 25.13 96031 20100416 SBUX 25.16 25.22 24.71 24.96 109072 20100419 SBUX 25.03 25.235 24.56 24.9 84914 20100420 SBUX 25.06 25.29 24.62 25.26 75338 20100421 SBUX 25.2 25.42 25 25.39 137329 20100422 SBUX 26 27.45 25.67 27.25 310504 20100423 SBUX 27.01 27.29 26.75 27.26 104491 20100426 SBUX 27.07 27.59 27 27.39 79381 20100427 SBUX 27.43 27.5 26.45 26.53 96204 20100428 SBUX 26.65 26.88 26.12 26.22 105977 20100429 SBUX 26.33 26.73 26.26 26.6 75962 20100430 SBUX 26.67 26.74 25.98 25.98 75038 20100503 SBUX 26.03 27.25 25.98 27.18 96655 20100504 SBUX 26.63 26.65 25.81 26.03 112351 20100505 SBUX 26.09 26.57 25.76 26.22 111534 20100506 SBUX 26 26.25 24.39 25.61 177871 20100507 SBUX 25.29 25.99 24.6501 25.4505 224074 20100510 SBUX 26.17 27.1 25.88 27.04 146675 20100511 SBUX 26.7 27.24 26.53 26.7 119968 20100512 SBUX 26.88 27.93 26.71 27.85 116675 20100513 SBUX 27.77 27.79 27.36 27.44 109628 20100514 SBUX 27.23 27.33 26.18 26.51 115408 20100517 SBUX 26.63 26.95 26.07 26.91 88257 20100518 SBUX 26.73 27.12 26.4 26.58 85599 20100519 SBUX 26.33 26.82 25.81 26.19 103567 20100520 SBUX 25.51 25.79 25.08 25.1 126002 20100521 SBUX 25.51 25.51 24.39 25.29 128619 20100524 SBUX 25.14 25.44 24.91 25.07 85397 20100525 SBUX 24.45 24.99 24.07 24.92 118768 20100526 SBUX 24.93 25.35 24.683 24.71 121023 20100527 SBUX 25.42 26.04 25.295 26.02 100519 20100528 SBUX 26.03 26.33 25.67 25.89 82621 20100601 SBUX 25.76 26.31 25.52 25.7 97673 20100602 SBUX 25.75 26.6 25.57 26.58 99660 20100603 SBUX 26.54 26.92 26.46 26.86 92290 20100604 SBUX 26.25 26.83 26 26.1525 114088 20100607 SBUX 26.21 26.25 25.51 25.54 98320 20100608 SBUX 25.55 25.91 25.2 25.85 99355 20100609 SBUX 26.06 26.72 26.01 26.31 118605 20100610 SBUX 26.56 27.01 26.4 26.98 94381 20100611 SBUX 26.77 27.21 26.74 27.15 86379 20100614 SBUX 27.43 27.86 27.28 27.46 87402 20100615 SBUX 27.59 27.94 27.414 27.93 86738 20100616 SBUX 27.77 28.17 27.62 27.99 94847 20100617 SBUX 28.01 28.11 27.6 27.98 71778 20100618 SBUX 27.99 28.36 27.74 28.09 94189 20100621 SBUX 28.29 28.5 27.86 28.02 66198 20100622 SBUX 28.03 28.48 27.15 27.23 103166 20100623 SBUX 27.23 27.52 26.9675 27.32 78959 20100624 SBUX 27.21 27.27 26.6 26.67 64796 20100625 SBUX 26.81 27.05 26.64 26.81 89347 20100628 SBUX 27.05 27.08 26.36 26.39 71981 20100629 SBUX 25.99 26.1 24.88 25.01 189466 20100630 SBUX 24.91 25.31 24.27 24.3 169650 20100701 SBUX 24.45 24.75 23.678 24.66 157496 20100702 SBUX 24.69 24.79 24.11 24.35 84655 20100707 SBUX 23.6 24.45 23.52\n\n---\n\nIRM 26.9 26.99 26.62 26.72 10259 20100408 IRM 26.56 26.61 26.27 26.52 9966 20100409 IRM 26.58 26.72 26.45 26.51 9527 20100412 IRM 26.53 26.64 26.42 26.5 13564 20100413 IRM 26.42 26.61 26.21 26.5 11057 20100414 IRM 26.55 26.915 26.33 26.88 20985 20100415 IRM 26.88 27.53 26.74 27.42 11802 20100416 IRM 27.42 27.67 27.05 27.22 14984 20100419 IRM 27.22 27.43 27.03 27.37 8724 20100420 IRM 27.46 27.82 27.32 27.74 10668 20100421 IRM 27.68 27.92 27.58 27.88 9912 20100422 IRM 27.66 28.35 27.52 28.31 11489 20100423 IRM 28.39 28.42 28.1 28.39 10657 20100426 IRM 28.31 28.49 28.15 28.26 9461 20100427 IRM 28.19 28.195 27.26 27.33 13317 20100428 IRM 27.65 28 27.51 28 10057 20100429 IRM 27.96 27.96 25.4 25.8 34844 20100430 IRM 25.86 25.89 24.97 25.15 20171 20100503 IRM 25.29 25.46 25.2 25.27 14151 20100504 IRM 24.95 25.12 24.61 25.07 19585 20100505 IRM 24.94 25.07 24.79 24.99 14365 20100506 IRM 24.77 25 22.62 23.89 18324 20100507 IRM 23.9 24.28 23.44 23.89 20275 20100510 IRM 24.9 25.31 24.76 25.11 17352 20100511 IRM 24.7 25.36 24.7 25.03 10954 20100512 IRM 25.08 25.5 25.08 25.5 8437 20100513 IRM 25.36 25.39 24.96 24.99 9970 20100514 IRM 24.89 24.94 24.29 24.48 9744 20100517 IRM 24.85 25.78 24.85 25.36 22097 20100518 IRM 26.02 26.25 25.44 25.67 23627 20100519 IRM 25.61 25.71 24.83 25.16 15450 20100520 IRM 24.74 24.74 23.89 23.95 17886 20100521 IRM 23.8 24.6 23.71 24.6 24111 20100524 IRM 24.45 24.66 24.18 24.23 15481 20100525 IRM 23.46 24.26 23.34 24.22 20356 20100526 IRM 24.49 24.89 24.171 24.25 14053 20100527 IRM 24.75 24.87 24.54 24.87 10104 20100528 IRM 24.87 24.87 24.365 24.52 8635 20100601 IRM 24.29 24.57 23.87 23.87 7601 20100602 IRM 24 24.33 23.85 24.33 9740 20100603 IRM 24.51 24.62 24.29 24.5 14658 20100604 IRM 24.15 24.2 23.29 23.39 19870 20100607 IRM 23.57 23.61 22.92 22.97 14789 20100608 IRM 23.1 23.27 22.74 23.2 23248 20100609 IRM 23.26 23.67 23.17 23.27 16938 20100610 IRM 23.63 23.84 23.299 23.82 13902 20100611 IRM 23.56 24.05 23.3955 24.05 9069 20100614 IRM 24.15 24.57 24.15 24.36 13273 20100615 IRM 24.57 25.01 24.56 25 9064 20100616 IRM 24.85 25.09 24.77 24.95 9551 20100617 IRM 24.95 24.95 24.26 24.47 13895 20100618 IRM 24.52 24.75 24.275 24.34 13772 20100621 IRM 24.72 24.74 23.96 24.02 12097 20100622 IRM 24.05 24.39 23.65 23.73 18518 20100623 IRM 23.56 23.6275 23.25 23.46 17087 20100624 IRM 23.48 23.91 23.345 23.5 19556 20100625 IRM 23.61 23.61 23.14 23.43 20754 20100628 IRM 23.6 23.61 23.21 23.27 9958 20100629 IRM 23.05 23.08 22.59 22.69 21197 20100630 IRM 22.61 22.93 22.44 22.46 17763 20100701 IRM 22.42 22.55 21.97 22.24 17542 20100702 IRM 22.21 22.41 21.96 22.01 7226 20100706 IRM 22.4 22.59 22 22.16 10978 20100707 IRM 22.28 23.07 22.2 23.06 13506 20100708 IRM 23.18 23.4 23.03 23.33 11271 20100709 IRM 23.36 23.56 23.19 23.52 11067 20100712 IRM 23.35 23.58 23.31 23.41 7307 20100713 IRM 23.64 24.1 23.6 24.02 9274 20100714 IRM 23.9 24.22 23.764 24.22 9346 20100715 IRM 24.21 24.28 23.81 24.21 8145 20100716 IRM 24.04 24.09 23.42 23.48 9016 20100719 IRM 23.51 23.72 23.1616 23.5 7717 20100720 IRM 23.07 24.07 23.07 24.06 8820 20100721 IRM 24.08 24.325 23.8832 24.11 15236 20100722 IRM 24.29 24.83 24.27 24.66 9875 20100723 IRM 24.64 25.12 24.54 25.1 9004 20100726 IRM 25.12 25.58 24.95 25.58 8247 20100727 IRM 25.68 25.68 25.35 25.5 17171 20100728 IRM 25.51 25.81 25.3 25.45 17890 20100729 IRM 25.01 25.35 23.93 24.06 24796 20100730 IRM 23.75 24.145 23.51 23.67 15659 20100802 IRM 23.93 24.41 23.79 24.37 12800 20100803 IRM 24.19 24.23 23.52 23.69 13885 20100804 IRM 23.69 23.775 23.42 23.61 15157 20100805 IRM 23.45 23.76 23.3087 23.52 9904 20100806 IRM 23.25 23.37 22.96 23.23 11346 20100809 IRM 23.31 23.41 23.24 23.35 11267 20100810 IRM 23.21 23.36 22.84 23.11 11517 20100811 IRM 22.84 22.84 22.28 22.28 8730 20100812 IRM 22.06 22.34 21.85 22.18 14478 20100813 IRM 22.13 22.2 21.97 21.97 8377 20100816 IRM 21.93 22.1 21.85 22 13622 20100817 IRM 22.18 22.275 21.98 22.01 17786 20100819 IRM 21.85 21.89 21.134 21.42 24342 20100820 IRM 21.22 21.59\n\n---\n\n15.44 15.3188 15.33 1040610 20091223 BAC 15.46 15.47 15.15 15.19 1021160 20091224 BAC 15.23 15.28 15.2 15.25 366117 20091228 BAC 15.31 15.41 15.15 15.29 1025732 20091229 BAC 15.3 15.33 15.1 15.12 830894 20091230 BAC 15.04 15.1 14.97 15.07 868978 20091231 BAC 15.09 15.24 15.01 15.06 943225 20100104 BAC 15.24 15.75 15.12 15.69 1808451 20100105 BAC 15.74 16.21 15.7 16.2 2095212 20100106 BAC 16.21 16.54 16.03 16.39 2052578 20100107 BAC 16.68 17.185 16.51 16.93 3208683 20100108 BAC 16.98 17.1 16.63 16.78 2201046 20100111 BAC 16.99 17.14 16.72 16.93 1689915 20100112 BAC 16.72 16.75 16.17 16.36 2234867 20100113 BAC 16.43 16.78 16.15 16.62 1926098 20100114 BAC 16.63 16.92 16.605 16.82 1429361 20100115 BAC 16.65 16.65 16.23 16.26 1952843 20100119 BAC 16.06 16.47 15.84 16.32 1816164 20100120 BAC 16.22 16.63 16.18 16.49 2887410 20100121 BAC 16.46 16.66 15.2 15.47 5512854 20100122 BAC 15.26 15.52 14.71 14.9 3696207 20100125 BAC 15.16 15.27 14.77 14.98 2623515 20100126 BAC 14.94 15.17 14.72 14.77 2123806 20100127 BAC 14.71 15.29 14.68 15.19 2587161 20100128 BAC 15.4 15.59 15.01 15.37 2328779 20100129 BAC 15.49 15.55 15.09 15.18 1751398 20100201 BAC 15.26 15.44 15.13 15.42 1595032 20100202 BAC 15.45 15.68 15.31 15.6 1715861 20100203 BAC 15.57 15.8 15.52 15.53 1308615 20100204 BAC 15.35 15.43 14.73 14.75 2525586 20100205 BAC 14.84 15.06 14.31 15 2976832 20100208 BAC 14.94 14.96 14.45 14.48 2082072 20100209 BAC 14.67 14.78 14.25 14.47 2515220 20100210 BAC 14.51 14.91 14.46 14.67 1757417 20100211 BAC 14.67 14.8 14.54 14.63 1410862 20100212 BAC 14.47 14.54 14.28 14.45 1628192 20100216 BAC 14.66 15.31 14.62 15.16 2054932 20100217 BAC 15.35 15.88 15.25 15.66 2615418 20100218 BAC 15.52 16 15.5 15.88 2421402 20100219 BAC 15.73 16.04 15.71 15.88 2161803 20100222 BAC 15.96 16.4 15.96 16.21 1737731 20100223 BAC 16.12 16.38 15.79 15.94 2104783 20100224 BAC 15.98 16.36 15.96 16.33 1915715 20100225 BAC 16.05 16.57 15.95 16.55 2873250 20100226 BAC 16.57 16.84 16.41 16.66 3436694 20100301 BAC 16.74 16.86 16.57 16.71 1709310 20100302 BAC 16.7 16.8 16.39 16.46 1830485 20100303 BAC 16.47 16.62 16.33 16.37 1549501 20100304 BAC 16.45 16.5 16.03 16.4 1577464 20100305 BAC 16.53 16.75 16.45 16.7 1724689 20100308 BAC 16.75 16.91 16.69 16.74 1277050 20100309 BAC 16.63 16.99 16.54 16.8 1677794 20100310 BAC 17.01 17.35 16.985 17.11 2229321 20100311 BAC 17.18 17.28 17.06 17.12 1450980 20100312 BAC 17.26 17.3 16.68 16.85 1714566 20100315 BAC 16.74 16.91 16.59 16.85 1203882 20100316 BAC 16.97 17.07 16.9 17.03 1074117 20100317 BAC 17.17 17.3 17.025 17.27 1344638 20100318 BAC 17.29 17.32 16.98 17.08 1239867 20100319 BAC 17.16 17.23 16.74 16.82 1782187 20100322 BAC 16.62 16.97 16.6 16.96 1136677 20100323 BAC 17.08 17.22 16.94 17.13 1312613 20100324 BAC 17.12 17.73 17.1 17.57 2708243 20100325 BAC 17.84 18.35 17.7 17.74 3153046 20100326 BAC 17.98 18.23 17.75 17.9 2209706 20100329 BAC 18.17 18.2 17.77 18.04 1525396 20100330 BAC 18.06 18.12 17.67 17.76 1443729 20100331 BAC 17.69 17.98 17.67 17.85 1142808 20100401 BAC 18.02 18.1 17.89 18.04 956072 20100405 BAC 18.17 18.25 18.02 18.13 1079892 20100406 BAC 18.16 18.54 18.1 18.49 1603165 20100407 BAC 18.58 18.86 18.53 18.62 2335222 20100408 BAC 18.59 18.84 18.31 18.65 1643054 20100409 BAC 18.82 18.85 18.5 18.59 1354805 20100412 BAC 18.68 18.82 18.6 18.66 1283189 20100413 BAC 18.61 18.72 18.49 18.67 1136877 20100414 BAC 18.98 19.42 18.92 19.4 2466246 20100415 BAC 19.63 19.8642 19.36 19.48 2400999 20100416 BAC 19.47 19.48 18.05 18.41 5890919 20100419 BAC 18.1 18.65 17.87 18.39 3588279 20100420 BAC 18.79 18.83 18.44 18.61 2005446 20100421 BAC 18.67 18.91 18.11 18.28 2021599 20100422 BAC 18.03 18.6 17.95 18.54 2194723 20100423 BAC 18.4 18.53 18.28 18.43 1454283 20100426 BAC 18.41 18.44 18.025 18.05 1608729 20100427 BAC 17.91 18.18 17.41 17.47 2594390 20100428 BAC 17.65 17.96 17.51 17.78 1952879 20100429 BAC 18.04 18.4 17.99 18.3 1772962 20100430 BAC 18.28 18.3 17.61 17.83 2315361 20100503 BAC 17.88 18.15 17.78 18.06 1507470 20100504\n\n---\n\nSBUX 25.99 26.1 24.88 25.01 189466 20100630 SBUX 24.91 25.31 24.27 24.3 169650 20100701 SBUX 24.45 24.75 23.678 24.66 157496 20100702 SBUX 24.69 24.79 24.11 24.35 84655 20100707 SBUX 23.6 24.45 23.52 24.4 90851 20100708 SBUX 24.47 24.93 24.39 24.84 104931 20100709 SBUX 24.84 25.34 24.84 25.3 70870 20100712 SBUX 25.3 25.52 24.978 25.27 64532 20100713 SBUX 25.57 26.07 25.47 25.94 79605 20100714 SBUX 25.86 26.15 25.75 26 59580 20100715 SBUX 26.02 26.18 25.64 26.13 62900 20100716 SBUX 26.07 26.44 25.27 25.35 97918 20100719 SBUX 25.35 25.71 25.08 25.49 72695 20100720 SBUX 25 25.7876 24.85 25.77 74257 20100721 SBUX 25.61 25.98 25.13 25.17 120653 20100722 SBUX 24.86 25.26 24.35 25.15 194232 20100723 SBUX 25.11 25.5 24.94 25.38 89468 20100726 SBUX 25.33 25.57 24.98 25.39 97510 20100727 SBUX 25.34 25.59 24.95 25.18 86000 20100728 SBUX 25.23 25.36 24.81 24.99 77161 20100729 SBUX 25.11 25.2 24.36 24.82 67063 20100730 SBUX 24.55 24.95 24.25 24.85 78412 20100802 SBUX 25.06 25.06 24.62 24.68 83369 20100803 SBUX 24.69 24.86 24.37 24.72 71889 20100805 SBUX 25.07 25.24 24.76 25.18 76722 20100806 SBUX 24.81 25.37 24.75 25.33 74908 20100809 SBUX 25.42 25.72 25.39 25.66 51787 20100810 SBUX 25.43 25.6 25.11 25.4 64512 20100811 SBUX 24.94 24.96 24.35 24.66 92258 20100812 SBUX 24.27 24.61 24.26 24.46 59819 20100813 SBUX 24.3 24.3725 23.95 23.99 60971 20100816 SBUX 23.8 24.15 23.668 23.82 73632 20100817 SBUX 23.9 24.59 23.84 24.295 70316 20100819 SBUX 24.34 24.524 23.86 24.04 68117 20100820 SBUX 24.04 24.11 23.76 24.05 54577 20090821 SCG 34.41 34.81 34.26 34.74 6378 20090824 SCG 34.78 34.89 34.67 34.83 7546 20090825 SCG 34.83 35.01 34.74 34.79 8620 20090826 SCG 34.79 34.89 34.64 34.86 7034 20090827 SCG 34.79 34.96 34.72 34.86 9150 20090828 SCG 35.1 35.1 34.72 34.95 6916 20090831 SCG 34.79 34.98 34.6 34.68 7958 20090901 SCG 34.6 35.02 34.47 34.74 12554 20090902 SCG 34.74 34.84 34.351 34.4 10935 20090903 SCG 34.6 34.6 34.09 34.39 7984 20090904 SCG 34.47 34.57 34.18 34.53 6709 20090909 SCG 34.35 34.38 34.07 34.23 8992 20090910 SCG 34.16 34.43 33.94 34.14 8730 20090911 SCG 34.14 34.21 33.8 33.86 7585 20090914 SCG 33.84 34.08 33.7 34.07 8986 20090915 SCG 34.12 34.24 33.975 34.11 10026 20090916 SCG 34.27 34.58 34 34.54 6714 20090917 SCG 34.54 34.77 34.41 34.44 8674 20090918 SCG 34.96 35.52 34.68 35.52 33757 20090921 SCG 35.3 35.63 35.05 35.3 9250 20090922 SCG 35.36 35.46 35 35.1 5939 20090923 SCG 35.23 35.68 35.08 35.21 6423 20090924 SCG 35.18 35.39 35.09 35.2 8199 20090925 SCG 35.15 35.28 35.04 35.17 10026 20090928 SCG 35.3 35.52 35.21 35.32 5672 20090929 SCG 35.43 35.48 35.14 35.3 6178 20090930 SCG 35.3 35.311 34.67 34.9 11417 20091001 SCG 34.58 34.98 34.5 34.5 6318 20091002 SCG 34.34 34.51 33.99 34.09 11062 20091005 SCG 34.23 34.57 33.94 34.53 7946 20091006 SCG 34.79 34.81 34.46 34.66 7707 20091007 SCG 34.67 34.68 34.43 34.64 4817 20091008 SCG 34.79 34.8 34.6 34.68 4085 20091009 SCG 34.7 34.82 34.63 34.82 2458 20091012 SCG 34.78 35.2 34.776 34.99 3687 20091013 SCG 34.91 34.91 34.685 34.73 5238 20091014 SCG 34.92 34.9956 34.67 34.85 3828 20091015 SCG 34.86 35.27 34.69 35.19 7105 20091016 SCG 34.93 35.18 34.66 34.85 14078 20091019 SCG 34.83 35.77 34.76 35.68 8284 20091020 SCG 35.64 35.69 35.2 35.35 4401 20091021 SCG 35.38 35.54 35.11 35.12 8269 20091022 SCG 35.22 35.39 34.96 35.34 8962 20091023 SCG 35.37 35.55 34.77 34.96 6617 20091026 SCG 35.05 35.44 34.54 34.59 6881 20091027 SCG 35.77 35.77 34.15 34.7 7588 20091028 SCG 34.64 34.699 34.24 34.32 13004 20091105 SCG 34.06 34.26 33.81 34.23 6635 20091106 SCG 34.2 34.31 33.91 34.15 7332 20091109 SCG 34.35 34.69 34.2 34.68 5069 20091110 SCG 34.7 34.96 34.62 34.95 8391 20091111 SCG 34.96 35.06 34.52 34.69 8534 20091112 SCG 34.68 34.76 34.17 34.23 6779 20091113 SCG 34.37 34.61 34.21 34.5 8672 20091116 SCG 34.65 35.03 34.5 35 7517 20091117 SCG 35.11 35.13 34.9 35.13 8279 20091118 SCG 35.12 35.13 34.8 34.84 6074 20091119 SCG 34.69 34.69 34.22 34.43 5447 20091120 SCG 34.37 34.64 34.28 34.62 7824 20091123 SCG 34.73\n\n---\n\n20091201 AMAT 12.43 12.95 12.4 12.89 332354 20091202 AMAT 12.88 13.0775 12.84 13 180437 20091203 AMAT 13.07 13.27 13.04 13.07 177815 20091204 AMAT 13.26 13.56 13.05 13.32 200643 20091207 AMAT 13.26 13.515 13.23 13.25 195194 20091208 AMAT 13.19 13.4 13.02 13.32 176929 20091209 AMAT 13.24 13.49 13.14 13.49 172993 20091210 AMAT 13.49 13.64 13.27 13.31 181459 20091211 AMAT 13.4 13.57 13.21 13.38 128189 20091214 AMAT 13.53 13.59 13.31 13.56 144259 20091215 AMAT 13.47 13.71 13.44 13.53 130251 20091216 AMAT 13.57 13.99 13.53 13.59 291171 20091217 AMAT 13.49 13.6 13.35 13.35 119600 20091218 AMAT 13.41 13.63 13.34 13.62 192396 20091221 AMAT 13.77 13.86 13.72 13.84 125594 20091222 AMAT 13.91 14.05 13.88 13.94 139393 20091223 AMAT 14.07 14.22 13.91 13.95 168989 20091224 AMAT 13.99 14.01 13.93 14 56635 20091228 AMAT 14.04 14.07 13.75 13.86 91901 20091229 AMAT 13.83 13.93 13.71 13.74 74504 20091230 AMAT 13.72 14.1 13.7 14.06 102158 20091231 AMAT 14.05 14.14 13.92 13.94 90303 20100104 AMAT 14.03 14.57 14.03 14.3 186159 20100105 AMAT 14.23 14.38 14.04 14.19 151737 20100106 AMAT 14.2 14.4 14.1 14.16 137049 20100107 AMAT 14.13 14.21 13.96 14.01 215495 20100108 AMAT 14.24 14.59 14.11 14.552 412148 20100111 AMAT 14.84 14.94 14.45 14.87 336715 20100112 AMAT 14.75 14.77 14.03 14.2 403508 20100113 AMAT 14.28 14.42 13.92 14.27 251382 20100114 AMAT 14.25 14.38 14.02 14.35 269335 20100115 AMAT 14.34 14.34 13.67 13.73 360347 20100119 AMAT 13.78 14.02 13.75 13.97 146214 20100120 AMAT 13.82 13.89 13.65 13.8 192211 20100121 AMAT 13.83 14.09 13.5205 13.58 252659 20100122 AMAT 13.36 13.39 12.61 12.63 481068 20100125 AMAT 12.67 12.94 12.59 12.64 397672 20100126 AMAT 12.75 13.01 12.64 12.65 369024 20100127 AMAT 12.75 13.07 12.69 13.04 304517 20100128 AMAT 13.07 13.09 12.35 12.61 350246 20100129 AMAT 12.8 12.85 12.15 12.18 256020 20100201 AMAT 12.32 12.56 12.23 12.52 202272 20100202 AMAT 12.58 12.59 12.35 12.51 215259 20100203 AMAT 12.36 12.48 12.12 12.28 361704 20100204 AMAT 12.15 12.22 11.66 11.8 407373 20100205 AMAT 11.82 12.27 11.68 12.23 437839 20100208 AMAT 12.2 12.33 12.03 12.07 179763 20100209 AMAT 12.29 12.4 12.04 12.15 211236 20100210 AMAT 12.23 12.315 12.1 12.23 172146 20100211 AMAT 12.21 12.53 12.06 12.47 183881 20100212 AMAT 12.32 12.72 12.15 12.47 237485 20100216 AMAT 12.67 12.97 12.56 12.95 216265 20100217 AMAT 13.09 13.15 12.75 12.99 252025 20100218 AMAT 12.78 12.79 12.31 12.68 452122 20100219 AMAT 12.64 12.64 12.35 12.5 290927 20100222 AMAT 12.53 12.585 12.39 12.45 226976 20100223 AMAT 12.46 12.48 11.94 12.01 302387 20100224 AMAT 12.08 12.42 12.05 12.27 256254 20100225 AMAT 12.05 12.25 11.94 12.22 217504 20100226 AMAT 12.27 12.3 12.03 12.24 158825 20100301 AMAT 12.3 12.5 12.29 12.5 164653 20100302 AMAT 12.55 12.64 12.35 12.42 224294 20100303 AMAT 12.46 12.55 12.34 12.39 170311 20100304 AMAT 12.4 12.48 12.09 12.26 274248 20100305 AMAT 12.34 12.43 12.23 12.29 239940 20100308 AMAT 12.52 12.53 12.31 12.36 297156 20100309 AMAT 12.3 12.415 12.24 12.29 245629 20100310 AMAT 12.26 12.55 12.26 12.53 351190 20100311 AMAT 12.48 12.52 12.28 12.41 305945 20100312 AMAT 12.52 12.55 12.3 12.36 250698 20100315 AMAT 12.33 12.33 12.12 12.23 236612 20100316 AMAT 12.25 12.49 12.2 12.45 297958 20100317 AMAT 12.5 12.69 12.45 12.66 277777 20100318 AMAT 12.7 12.77 12.53 12.63 186893 20100319 AMAT 12.71 12.71 12.37 12.49 247673 20100322 AMAT 12.43 12.82 12.39 12.78 262570 20100323 AMAT 12.83 13.32 12.8 13.235 396508 20100324 AMAT 13.17 13.23 12.91 13 341346 20100325 AMAT 13.15 13.38 13.09 13.16 382806 20100326 AMAT 13.27 13.45 13.01 13.21 300929 20100329 AMAT 13.23 13.45 13.22 13.31 278288 20100330 AMAT 13.35 13.6 13.23 13.45 393648 20100331 AMAT 13.44 13.75 13.43 13.4675 408143 20100401 AMAT 13.63 13.73 13.2666 13.35 371164 20100405 AMAT 13.42 13.61 13.37 13.52 293320 20100406 AMAT 13.49 13.555 13.39 13.48 164524 20100407 AMAT 13.45 13.71 13.37 13.58 208716 20100408 AMAT 13.5 13.5 13.3 13.34 291794 20100409 AMAT 13.35 13.47 13.31 13.465 154474 20100412 AMAT 13.49 13.74\n\n---\n\n5.845 5.36 5.77 83804 20100512 NOVL 5.8 5.83 5.63 5.75 56592 20100513 NOVL 5.73 6.06 5.715 5.86 78830 20100514 NOVL 5.81 5.905 5.75 5.84 53196 20100517 NOVL 5.81 5.91 5.74 5.88 66451 20100518 NOVL 5.9 5.95 5.8 5.82 64876 20100519 NOVL 5.81 6.08 5.8 6.03 84049 20100520 NOVL 6.03 6.06 5.87 5.91 80917 20100521 NOVL 5.79 6 5.75 6 48472 20100524 NOVL 6 6.015 5.92 5.94 16129 20100525 NOVL 5.77 5.92 5.75 5.91 45496 20100526 NOVL 5.86 5.96 5.8 5.81 43456 20100527 NOVL 5.88 5.91 5.83 5.9 28026 20100528 NOVL 5.9 5.93 5.83 5.83 31402 20100601 NOVL 5.82 5.85 5.75 5.76 26740 20100602 NOVL 5.78 5.9 5.77 5.85 24114 20100603 NOVL 5.85 6.05 5.8101 6.03 31653 20100604 NOVL 5.86 5.98 5.85 5.9 36681 20100607 NOVL 5.9 5.98 5.89 5.96 50094 20100608 NOVL 5.96 6 5.91 5.98 59189 20100609 NOVL 6 6 5.89 5.89 42043 20100610 NOVL 6.02 6.1 5.94 6.09 26497 20100611 NOVL 6.01 6.27 6.01 6.26 73032 20100614 NOVL 6.22 6.36 6.14 6.19 65685 20100615 NOVL 6.16 6.26 6.16 6.24 22522 20100616 NOVL 6.2 6.24 6.09 6.16 22683 20100617 NOVL 6.16 6.18 6.05 6.12 18111 20100618 NOVL 6.1 6.15 6.07 6.12 31903 20100621 NOVL 6.14 6.15 5.97 6.01 23041 20100622 NOVL 6.01 6.1 5.96 5.99 24027 20100623 NOVL 6.02 6.05 5.89 6.01 23495 20100624 NOVL 5.99 6.02 5.9 5.95 27858 20100625 NOVL 5.96 6.07 5.91 5.9475 59960 20100628 NOVL 5.95 6.03 5.925 5.94 14546 20100629 NOVL 5.84 5.88 5.72 5.76 35739 20100630 NOVL 5.79 5.86 5.65 5.68 40950 20100701 NOVL 5.7 5.9 5.69 5.82 53842 20100702 NOVL 5.84 5.97 5.84 5.91 37194 20100706 NOVL 5.95 5.965 5.78 5.84 35468 20100707 NOVL 5.88 5.89 5.81 5.89 29997 20100708 NOVL 5.85 5.98 5.84 5.98 45064 20100709 NOVL 5.95 6.06 5.88 6.06 23943 20100712 NOVL 6.02 6.15 5.98 6.14 31232 20100713 NOVL 6.17 6.2 6.13 6.2 35631 20100714 NOVL 6.15 6.18 6.1 6.15 34348 20100715 NOVL 6.13 6.195 6.08 6.18 28040 20100716 NOVL 6.12 6.2 6.07 6.1 32119 20100719 NOVL 6.1 6.21 6.02 6.17 40151 20100720 NOVL 6.125 6.2 6 6.17 33421 20100721 NOVL 6.16 6.18 6 6.01 12484 20100722 NOVL 6.11 6.16 6.05 6.11 15581 20100723 NOVL 6.12 6.19 6.1 6.16 10588 20100726 NOVL 6.16 6.2 6.13 6.2 20392 20100727 NOVL 6.19 6.2 6.14 6.2 15814 20100728 NOVL 6.16 6.19 6.02 6.12 19101 20100729 NOVL 6.14 6.14 5.98 5.98 27560 20100730 NOVL 5.98 6.04 5.94 6.04 28064 20100802 NOVL 6.09 6.12 6.02 6.09 14096 20100803 NOVL 6.08 6.09 5.99 6.05 14004 20100804 NOVL 6.05 6.11 5.97 6.11 18282 20100806 NOVL 6.05 6.12 6 6.08 19371 20100809 NOVL 6.08 6.1 5.98 6.01 16316 20100810 NOVL 5.87 6 5.75 5.82 98531 20100811 NOVL 5.73 5.76 5.54 5.59 105436 20100812 NOVL 5.54 5.65 5.52 5.535 60669 20100813 NOVL 5.57 5.69 5.53 5.68 33596 20100816 NOVL 5.63 5.85 5.61 5.8 30466 20100817 NOVL 5.87 5.94 5.825 5.93 30724 20100819 NOVL 5.87 5.94 5.73 5.77 19563 20100820 NOVL 5.75 5.86 5.73 5.81 29790 20100201 NRG 24.15 24.23 23.56 23.9 65175 20100202 NRG 23.89 23.89 23.39 23.56 63730 20100203 NRG 23.42 23.55 23.05 23.11 39935 20100204 NRG 23 23 22.045 22.1 55791 20100205 NRG 22.09 22.13 21.38 21.71 58255 20100208 NRG 21.74 22.01 21.56 21.59 37852 20100209 NRG 21.86 22.27 21.74 21.89 43630 20100210 NRG 21.9 21.91 21.34 21.66 35605 20100211 NRG 21.95 22.28 21.68 22.22 45361 20100212 NRG 22.05 22.07 21.65 22.06 40441 20100216 NRG 22.13 22.49 22.1 22.49 26898 20100217 NRG 22.55 22.76 22.41 22.59 34664 20100218 NRG 22.41 22.65 22.28 22.57 43483 20100219 NRG 22.59 23.45 22.44 23.2 51922 20100222 NRG 23.42 23.52 23.05 23.07 39919 20100223 NRG 22.5 22.88 22.2 22.26 51587 20100224 NRG 22.33 22.5 21.57 21.86 55363 20100225 NRG 21.42 22.13 21.36 22.07 51948 20100226 NRG 22.11 22.24 21.6 21.84 50763 20100301 NRG 21.89 22.66 21.88 22.58 44542 20100302 NRG 22.66 22.965 22.64 22.67 53423 20100303 NRG 22.74 22.98 22.48 22.5 41670 20100304 NRG 22.41 22.43 22 22.3 56326 20100305 NRG 22.34 23.02 22.34 22.82 46656 20100308 NRG 22.8 23.03 22.7 22.9 18574 20100309 NRG 22.83 22.98 22.72 22.75 24259 20100310 NRG 22.7 22.83 22.56 22.64 28476 20100311 NRG 22.56 22.94 22.52 22.94 28327 20100312 NRG 22.73 22.88 22.07 22.19 52320 20100315 NRG 22.16 22.35 22.02 22.27\n\n---\n\n14.61 14.87 1540554 20090910 GE 14.92 14.94 14.52 14.8 1198800 20090911 GE 14.87 14.98 14.63 14.67 1012190 20090914 GE 14.55 15.41 14.4 15.35 1392840 20090915 GE 15.49 16.15 15.48 16 2091985 20090916 GE 16.39 17.18 16.33 17 2689680 20090917 GE 16.97 17.52 16.35 16.66 2550665 20090918 GE 16.88 16.88 16.43 16.5 1230240 20090921 GE 16.43 16.89 16.24 16.76 1092990 20090922 GE 17.06 17.19 16.91 17.01 959104 20090923 GE 17.17 17.5 16.95 17 1344096 20090924 GE 17.06 17.17 16.34 16.58 1232292 20090925 GE 16.35 16.57 16.06 16.37 1037357 20090928 GE 16.47 16.91 16.44 16.76 737865 20090929 GE 16.91 17.09 16.67 16.71 807781 20090930 GE 16.83 16.86 16.31 16.42 1207635 20091001 GE 16.31 16.39 15.95 15.97 1134940 20091002 GE 15.45 15.66 15.15 15.36 1330917 20091005 GE 15.59 15.91 15.51 15.83 739009 20091006 GE 16.14 16.4001 16 16.08 956979 20091007 GE 16.03 16.32 15.91 16.16 609114 20091008 GE 16.46 16.55 16.2 16.22 773694 20091009 GE 16.2 16.37 16.1 16.18 704068 20091012 GE 16.36 16.49 16.27 16.33 586272 20091013 GE 16.32 16.54 16.08 16.39 706429 20091014 GE 16.77 16.87 16.56 16.84 925694 20091015 GE 16.79 16.84 16.48 16.79 923288 20091016 GE 16.35 16.41 15.85 16.08 1823347 20091019 GE 16.05 16.13 15.8 15.84 992456 20091020 GE 15.8 15.82 15.47 15.58 1010874 20091021 GE 15.51 15.95 15.5 15.53 966835 20091022 GE 15.5 15.58 15.11 15.34 1251213 20091023 GE 15.37 15.4 15.11 15.2 880866 20091026 GE 15.24 15.45 14.83 15.01 962708 20091027 GE 15.07 15.14 14.86 14.93 874651 20091028 GE 14.77 14.82 14.35 14.42 1072727 20091105 GE 14.28 14.55 14.21 14.43 705440 20091106 GE 14.98 15.49 14.83 15.33 1650533 20091109 GE 15.7 15.92 15.6 15.85 1029088 20091110 GE 15.95 15.99 15.48 15.78 736000 20091111 GE 15.94 15.97 15.65 15.83 712973 20091112 GE 15.8 15.94 15.66 15.75 656096 20091113 GE 15.76 15.8 15.56 15.66 654318 20091116 GE 15.8 16.19 15.77 16 982478 20091117 GE 15.96 16.08 15.89 16.02 520384 20091118 GE 16.01 16.14 15.95 16.09 475687 20091119 GE 15.92 15.96 15.5741 15.76 697712 20091120 GE 15.66 15.72 15.45 15.59 639159 20091123 GE 15.83 16.04 15.83 16.02 739054 20091124 GE 16.08 16.2 15.92 16.12 807053 20091125 GE 16.24 16.25 16.0377 16.18 481709 20091127 GE 15.49 16.08 15.3 15.94 609175 20091130 GE 15.82 16.06 15.81 16.02 701684 20091201 GE 16.27 16.35 15.96 16.17 980342 20091202 GE 16.12 16.22 15.96 16.07 653246 20091203 GE 16.12 16.31 16 16 745557 20091204 GE 16.34 16.49 16.06 16.2 884109 20091207 GE 16.07 16.24 16.01 16.08 644173 20091208 GE 15.9 15.93 15.65 15.72 788521 20091209 GE 15.73 15.79 15.52 15.66 586965 20091210 GE 15.81 15.85 15.55 15.61 557820 20091211 GE 15.72 16 15.69 15.92 564486 20091214 GE 15.98 16.07 15.92 15.95 438574 20091215 GE 15.83 16.021 15.65 15.75 792412 20091216 GE 15.8 15.85 15.66 15.69 725444 20091217 GE 15.59 15.95 15.55 15.79 682736 20091218 GE 15.91 15.91 15.587 15.59 792024 20091221 GE 15.69 15.79 15.535 15.57 531453 20091222 GE 15.57 15.69 15.43 15.48 481672 20091223 GE 15.46 15.48 15.31 15.41 423407 20091224 GE 15.38 15.48 15.36 15.44 185801 20091228 GE 15.38 15.43 15.26 15.34 457447 20091229 GE 15.36 15.53 15.3 15.44 483941 20091230 GE 15.31 15.37 15.26 15.35 449500 20091231 GE 15.27 15.34 15.13 15.13 445315 20100104 GE 15.22 15.64 15.15 15.45 670798 20100105 GE 15.46 15.67 15.45 15.53 645505 20100106 GE 15.53 15.62 15.44 15.45 554648 20100107 GE 15.48 16.48 15.43 16.25 1854722 20100108 GE 16.31 16.69 16.27 16.6 1151125 20100111 GE 16.83 16.88 16.54 16.76 766753 20100112 GE 16.58 16.835 16.57 16.77 646227 20100113 GE 16.76 16.92 16.57 16.83 653423 20100114 GE 16.79 16.87 16.68 16.7 573808 20100115 GE 16.68 16.75 16.35 16.44 741235 20100119 GE 16.35 16.75 16.34 16.54 606973 20100120 GE 16.5 16.6817 16.33 16.5 644955 20100121 GE 16.47 16.48 15.95 16.02 991511 20100122 GE 16.55 16.76 16.09 16.11 1626776 20100125 GE 16.46 16.53 16.22 16.37 751603 20100126 GE 16.33 16.7 16.26 16.35 780268 20100127 GE 16.29 16.39 16.03 16.3 768505 20100128 GE 16.43 16.45 16.01 16.16 791626 20100129 GE 16.22 16.5 16.07 16.08 811615\n\n---\n\n20.62 20.78 10548 20100303 SEE 20.82 20.9 20.73 20.85 9386 20100304 SEE 20.81 20.9 20.31 20.53 14691 20100305 SEE 20.73 20.94 20.62 20.91 12077 20100308 SEE 20.93 21.14 20.74 20.88 13096 20100309 SEE 20.77 20.82 20.57 20.7 16633 20100310 SEE 20.69 20.98 20.46 20.84 17465 20100311 SEE 20.76 20.89 20.61 20.86 5664 20100312 SEE 21.01 21.16 20.9 21.1 9363 20100315 SEE 21.11 21.19 20.96 21.18 8626 20100316 SEE 21.19 21.5 21.18 21.48 11478 20100317 SEE 21.48 21.76 21.39 21.71 11241 20100318 SEE 21.75 21.81 21.64 21.74 10791 20100319 SEE 21.75 22.1 21.5 21.6 13045 20100322 SEE 21.53 21.83 21.44 21.75 10852 20100323 SEE 21.73 21.77 21.515 21.74 11041 20100324 SEE 21.68 21.69 21.46 21.47 8852 20100325 SEE 21.63 21.75 21.28 21.28 15270 20100326 SEE 21.33 21.56 21.14 21.31 9253 20100329 SEE 21.32 21.56 21.16 21.28 12882 20100330 SEE 21.27 21.39 21.15 21.38 12731 20100331 SEE 21.28 21.38 21.06 21.08 10792 20100401 SEE 21.29 21.53 21.181 21.33 10745 20100405 SEE 21.45 21.71 21.34 21.7 6353 20100406 SEE 21.67 21.79 21.55 21.76 12145 20100407 SEE 21.68 21.87 21.45 21.51 15145 20100408 SEE 21.42 21.69 21.29 21.67 10183 20100409 SEE 21.7 21.753 21.55 21.7 8425 20100412 SEE 21.73 21.8 21.39 21.49 9439 20100413 SEE 21.43 21.51 21.19 21.48 10442 20100414 SEE 21.5 22.13 21.5 22.13 15940 20100415 SEE 22.16 22.7 22.02 22.7 19871 20100416 SEE 22.73 22.86 22.35 22.45 23972 20100419 SEE 22.32 22.59 22.265 22.56 13149 20100420 SEE 22.64 22.99 22.585 22.94 13518 20100421 SEE 23.02 23.41 22.96 23.08 15170 20100422 SEE 22.97 23.21 22.76 23.2 9839 20100423 SEE 23.17 23.36 23.02 23.26 9332 20100426 SEE 23.32 23.43 23 23.13 12424 20100427 SEE 23.03 23.18 22.72 22.76 23438 20100428 SEE 22.96 23.18 21.95 22.3 28046 20100429 SEE 22.38 22.47 22.04 22.29 11326 20100430 SEE 22.37 22.49 21.45 21.5 18685 20100503 SEE 21.64 21.71 21.35 21.68 16739 20100504 SEE 21.41 21.65 21.28 21.51 20412 20100505 SEE 21.34 21.75 21.18 21.44 15534 20100506 SEE 21.31 21.49 19.32 20.68 19123 20100507 SEE 20.6 20.95 20.16 20.58 25939 20100510 SEE 21.49 21.61 21.22 21.46 11355 20100511 SEE 21.27 21.41 21.02 21.05 13522 20100512 SEE 21.06 21.42 21.02 21.37 7641 20100513 SEE 21.34 21.75 21.12 21.54 14044 20100514 SEE 21.44 21.5 21 21.14 13989 20100517 SEE 21.3 22.82 21.3 22.32 30945 20100518 SEE 22.41 22.53 21.545 21.55 19280 20100519 SEE 21.47 21.79 21.32 21.72 17304 20100520 SEE 21.17 21.29 20.63 20.63 15561 20100521 SEE 20.47 20.98 20.04 20.96 21129 20100524 SEE 20.78 20.89 20.51 20.58 14392 20100525 SEE 20.13 20.62 19.83 20.62 14028 20100526 SEE 20.77 20.91 20.4 20.47 14405 20100527 SEE 20.89 21.08 20.53 21.07 13659 20100528 SEE 21.07 21.12 20.72 20.84 9441 20100601 SEE 20.6 20.875 20.24 20.27 10846 20100602 SEE 20.25 20.65 20.14 20.64 8166 20100603 SEE 20.71 20.87 20.59 20.83 9362 20100604 SEE 20.44 20.72 20.02 20.11 14346 20100607 SEE 20.11 20.18 19.87 19.96 15928 20100608 SEE 19.93 20.15 19.71 20.07 22483 20100609 SEE 20.18 20.41 19.99 20.22 18349 20100610 SEE 20.52 20.75 20.3 20.6 11011 20100611 SEE 20.39 20.91 20.3301 20.85 11273 20100614 SEE 21.05 21.31 20.87 20.93 8214 20100615 SEE 21.03 21.34 21.03 21.34 10063 20100616 SEE 21.13 21.32 21.01 21.18 8520 20100617 SEE 21.27 21.38 21.09 21.37 9072 20100618 SEE 21.45 21.54 21.36 21.52 10151 20100621 SEE 21.83 21.86 21.22 21.4 8803 20100622 SEE 21.41 21.5 20.9 20.93 6141 20100623 SEE 20.92 21.09 20.65 20.89 8460 20100624 SEE 20.87 21.14 20.6 20.65 7646 20100625 SEE 20.69 20.81 20.42 20.69 8726 20100628 SEE 20.7 20.79 20.39 20.43 7625 20100629 SEE 20.16 20.39 19.9 20 13331 20100630 SEE 19.94 20.09 19.62 19.72 17337 20100701 SEE 19.74 19.83 19.28 19.59 10788 20100702 SEE 19.65 19.66 19.34 19.49 8319 20100706 SEE 19.7 19.86 19.48 19.77 20966 20100707 SEE 19.84 20.32 19.73 20.32 12596 20100708 SEE 20.44 20.69 20.31 20.68 9374 20100709 SEE 20.8 20.93 20.68 20.85 6287 20100712 SEE 20.85 21.2 20.81 20.86 7326 20100713 SEE 21.02 21.63 21.02 21.57 9073 20100714 SEE 21.49 21.64 21.29 21.58 8212 20100715 SEE 21.6 21.87 21.47 21.81 10734 20100716\n\n---\n\nSII 48.55 49.66 48.21 48.83 201169 20100430 SII 49.03 49.2 46.6 47.76 170794 20100503 SII 47.76 48.29 46.94 47.76 115480 20100504 SII 46.71 47.47 45.9 46.15 71278 20100505 SII 45.12 45.92 44.39 45.15 80377 20100506 SII 45.06 45.77 40.63 43.65 101066 20100507 SII 43.4 43.97 41.47 41.88 107612 20100510 SII 43.9 44.96 43.78 44.87 102878 20100511 SII 44.27 45.6 44.21 44.75 63254 20100512 SII 45.08 45.26 43.95 44.75 35583 20100513 SII 44.94 45.85 44.21 44.84 41928 20100514 SII 44.55 44.66 42.94 43.54 46048 20100517 SII 43.36 43.89 41.9 43.02 50234 20100518 SII 43.6 44.34 42.62 42.88 57255 20100519 SII 42.63 43.35 41.4 41.95 72350 20100520 SII 40.69 40.91 39.39 39.4 130123 20100521 SII 39.04 40.46 38.56 40.36 99756 20100524 SII 40.24 40.37 38.24 38.31 63781 20100525 SII 37.25 39.19 37.08 39.06 72943 20100526 SII 39.6 40.4 39.15 39.28 50084 20100527 SII 40.29 40.87 39.33 40.17 66717 20100528 SII 39.75 39.89 37.19 37.56 93961 20100601 SII 36.55 36.73 34.44 34.45 112343 20100602 SII 35.56 37.75 35.42 37.7 72736 20100603 SII 38.39 38.46 36.47 37.97 77320 20100604 SII 37.38 38.82 37.04 37.38 68191 20100607 SII 37.5 38.04 36.35 36.48 49741 20100608 SII 36.54 37.62 36.1503 37.52 75278 20100609 SII 38.01 39.15 37.19 37.35 61712 20100610 SII 38.85 40.15 38.78 40.09 45155 20100611 SII 39.43 40.35 39.35 40.23 51751 20100614 SII 40.9 41.18 39.56 39.68 58830 20100615 SII 40.33 41.35 40 41.23 32753 20100616 SII 40.44 41.75 40.44 41.15 36536 20100617 SII 41.5 41.7 40.96 41.49 49642 20100618 SII 41.44 41.46 40.28 41.18 52741 20100621 SII 41.96 42.03 40.63 41 30748 20100622 SII 41.06 41.23 39.55 39.62 67036 20100623 SII 39.54 40.01 39.06 39.68 49378 20100624 SII 39.43 39.74 38.75 38.82 43387 20100625 SII 38.96 39.92 38.63 39.47 84600 20100628 SII 39.54 39.7 38.91 39.07 43451 20100629 SII 37.92 38.48 37.35 37.47 57438 20100630 SII 37.58 38.58 37.47 37.65 50216 20100701 SII 37.79 38.09 36.51 37.73 59021 20100702 SII 37.79 38.33 37.02 37.52 37419 20100706 SII 38.65 38.77 37.3 37.9 47646 20100707 SII 37.93 39.33 37.88 39.3 57649 20100708 SII 39.71 40.05 39.015 40.05 39819 20100709 SII 40.08 40.27 39.59 40.06 24511 20100712 SII 40.05 40.4 39.45 39.99 28168 20100713 SII 40.59 40.98 40.24 40.33 26533 20100714 SII 39.94 40.8625 39.81 40.38 34156 20100715 SII 40.24 40.43 39.42 40.29 48777 20100716 SII 40.06 40.16 39.11 39.15 132872 20100719 SII 39.78 41.26 39.59 40.92 74264 20100720 SII 40.38 42.41 40.135 42.22 66690 20100721 SII 42.39 42.55 40.75 41.17 59273 20100722 SII 41.93 42.84 41.69 42.38 49300 20100723 SII 40.985 41.5 40.3 41.06 57465 20100726 SII 41.26 41.27 40 40.73 35759 20100727 SII 40.92 41.11 39.88 40.85 58052 20100728 SII 40.78 41.725 40.69 41.43 47063 20100729 SII 41.81 42.36 40.785 41.59 47115 20100730 SII 40.97 41.68 40.8 41.48 32061 20100802 SII 42.41 44.02 42.3 43.61 65610 20100803 SII 43.04 44.01 42.95 43.68 46229 20100804 SII 43.76 44.25 43.31 43.68 28656 20100805 SII 43.43 43.95 43.05 43.88 22383 20100806 SII 43.46 43.98 42.68 43.35 28624 20100809 SII 43.71 43.88 43.35 43.58 22249 20100810 SII 42.82 43.44 42.51 43.23 35942 20100811 SII 42.28 42.42 41.43 41.73 50995 20100812 SII 41.02 41.61 40.72 41.17 45494 20100813 SII 40.94 41.56 40.8 40.82 23310 20100816 SII 40.63 41.57 40.57 41.26 27031 20100817 SII 41.76 42.4 41.46 42 19835 20100819 SII 40.93 41.26 39.87 40.17 34647 20100820 SII 39.77 39.94 38.82 39.24 26736 20090821 SJM 53.95 55.36 53.56 54.1 25558 20090824 SJM 54.3 54.58 52.84 53.16 10239 20090825 SJM 53.27 53.47 52.33 52.47 10640 20090826 SJM 52.63 52.7 51.73 51.9 9859 20090827 SJM 51.69 52.04 51.33 51.92 6721 20090828 SJM 51.88 52.45 51.69 51.9 8013 20090831 SJM 51.85 52.28 51.7 52.27 7378 20090901 SJM 52.24 52.28 51.11 51.33 8495 20090902 SJM 51.31 51.75 51.12 51.46 6023 20090903 SJM 51.57 51.69 50.9 51.59 13103 20090904 SJM 51.27 51.75 51 51.73 6047 20090909 SJM 53.06 53.86 52.82 53.12 11721 20090910 SJM 53.2 53.44 52.49 53.44 9989 20090911 SJM 53.61 54 53.32 53.84 7280 20090914 SJM 53.62 53.62 53.14 53.34 6518 20090915 SJM\n\n---\n\n24.5 24.73 8359 20091124 IRM 24.78 24.78 24.3738 24.62 9942 20091125 IRM 24.7 24.88 24.65 24.81 7482 20091127 IRM 24.43 24.73 24.14 24.52 5494 20091130 IRM 24.44 24.54 23.91 24 14591 20091201 IRM 24.23 24.26 23.9 24 13476 20091202 IRM 24.04 24.39 23.9 24.05 22559 20091203 IRM 24.02 24.1937 23.75 23.77 8947 20091204 IRM 23.98 24.2 23.76 24 12357 20091207 IRM 24.08 24.08 23.68 23.84 14995 20091208 IRM 23.76 23.76 23.24 23.35 16290 20091209 IRM 23.29 23.44 23.05 23.41 12163 20091210 IRM 23.43 23.72 23.42 23.62 9741 20091211 IRM 23.64 23.93 23.55 23.81 5790 20091214 IRM 23.87 24.08 23.76 23.89 8386 20091215 IRM 23.78 23.9 23.58 23.66 7628 20091216 IRM 23.68 23.83 23.445 23.53 8548 20091217 IRM 23.46 23.56 23.17 23.18 8225 20091218 IRM 23.19 23.36 22.82 23.17 16780 20091221 IRM 23.35 23.59 23.3 23.4 5955 20091222 IRM 23.42 23.56 23.4 23.53 7276 20091223 IRM 23.45 23.53 23.26 23.39 5740 20091224 IRM 23.49 23.49 23.34 23.41 2059 20091228 IRM 23.4 23.5 23.19 23.23 3680 20091229 IRM 23.34 23.4 23.18 23.23 6378 20091230 IRM 23.23 23.31 22.89 23 9016 20091231 IRM 23.12 23.29 22.74 22.76 6384 20100104 IRM 22.87 23.06 22.68 22.89 9200 20100105 IRM 22.83 23.03 22.7 22.96 10352 20100106 IRM 22.99 23.77 22.94 23.7 18252 20100107 IRM 23.68 24.08 23.61 24.08 14037 20100108 IRM 24 24.23 23.83 24.15 9690 20100111 IRM 24.2 24.4 23.99 24.33 9372 20100112 IRM 24.14 24.43 23.95 24.04 14838 20100113 IRM 24.09 24.68 24.09 24.66 9263 20100114 IRM 24.65 24.86 24.36 24.83 11219 20100115 IRM 24.75 24.93 24.25 24.38 11656 20100119 IRM 24.35 24.81 24.26 24.73 8862 20100120 IRM 24.53 24.56 24.16 24.3 6295 20100121 IRM 24.26 24.44 24.02 24.07 13113 20100122 IRM 24.08 24.11 23.71 23.74 14418 20100125 IRM 23.92 23.96 23.4 23.57 8371 20100126 IRM 23.54 23.65 23.19 23.2 7713 20100127 IRM 23.18 23.35 22.91 23.21 11918 20100128 IRM 23.26 23.26 22.8 22.9 7251 20100129 IRM 23.09 23.2 22.82 22.86 14834 20100201 IRM 22.97 23.135 22.86 22.98 9382 20100202 IRM 22.98 23.28 22.9 23.23 9856 20100203 IRM 23.15 23.43 23.05 23.11 8078 20100204 IRM 22.86 23.06 22.58 22.59 13856 20100205 IRM 22.51 22.75 21.95 22.1 27247 20100208 IRM 22.08 22.12 21.8 21.8 12296 20100209 IRM 22.04 22.18 21.78 21.94 11567 20100210 IRM 21.94 22.05 21.5 21.62 15762 20100211 IRM 21.58 21.92 21.32 21.73 17130 20100212 IRM 21.6 21.78 21.38 21.71 15416 20100216 IRM 21.85 22.41 21.69 22.4 11866 20100217 IRM 23.12 23.67 22.86 23.55 29934 20100218 IRM 23.59 23.89 23.5 23.84 12189 20100219 IRM 23.76 24.42 23.76 24.15 17870 20100222 IRM 24.28 24.44 23.69 23.87 16508 20100223 IRM 23.84 24.1 23.77 23.87 18686 20100224 IRM 23.98 24.45 23.94 24.3 23210 20100225 IRM 25.52 26.48 25.51 26.02 39638 20100226 IRM 26.12 26.24 25.81 25.88 20217 20100301 IRM 26.09 26.1 25.67 25.99 20794 20100302 IRM 26.12 26.15 25.71 25.83 12647 20100303 IRM 25.93 26.03 25.52 25.62 13923 20100304 IRM 25.69 25.7 25.36 25.64 9288 20100305 IRM 25.71 25.99 25.63 25.83 11017 20100308 IRM 25.93 26.01 25.76 25.84 6942 20100309 IRM 25.79 25.8252 25.49 25.65 11711 20100310 IRM 25.65 25.87 25.62 25.64 10709 20100311 IRM 25.53 25.8 25.42 25.77 6713 20100312 IRM 25.82 25.95 25.67 25.91 5875 20100315 IRM 26 26.12 25.82 26.05 8226 20100316 IRM 26.12 26.16 25.91 26.1 9241 20100317 IRM 26.29 26.41 26.07 26.39 8845 20100318 IRM 26.39 26.42 26.22 26.36 6167 20100319 IRM 26.41 26.55 25.9 26 11825 20100322 IRM 25.84 26.44 25.84 26.32 8405 20100323 IRM 26.55 27.28 26.44 27.28 17101 20100324 IRM 27.11 27.4 26.94 27.02 13172 20100325 IRM 27.27 27.52 27.07 27.1 13253 20100326 IRM 27.26 27.48 26.81 27.03 9221 20100329 IRM 27.07 27.74 27.07 27.74 13247 20100330 IRM 27.71 27.76 27.32 27.42 10949 20100331 IRM 27.23 27.45 27.08 27.4 11760 20100401 IRM 27.62 28 27.23 27.45 12633 20100405 IRM 27.53 27.55 27.21 27.3 11100 20100406 IRM 27.11 27.17 26.88 27.01 13262 20100407 IRM 26.9 26.99 26.62 26.72 10259 20100408 IRM 26.56 26.61 26.27 26.52 9966 20100409 IRM 26.58 26.72 26.45 26.51 9527 20100412 IRM 26.53 26.64 26.42 26.5 13564 20100413 IRM 26.42 26.61 26.21 26.5 11057\n\n---\n\n74.23 74.34 4038 20090825 DNB 74.91 75.07 73.85 74.26 4558 20090826 DNB 73.99 74.32 73.46 73.85 4202 20090827 DNB 73.63 74.1 72.67 73.37 3917 20090828 DNB 73.49 73.697 72.76 72.95 5499 20090831 DNB 72.84 73.18 72.62 73.04 3578 20090901 DNB 72.82 73.55 72.6 72.97 8135 20090902 DNB 72.65 73.19 72.2 72.94 6238 20090903 DNB 72.85 74.24 71.15 74.24 5219 20090904 DNB 73.93 74.89 73.93 74.55 4017 20090909 DNB 74.455 74.455 73.12 73.41 8212 20090910 DNB 73.4 73.78 72.89 73.39 7758 20090911 DNB 73.39 74.27 72.75 73.97 8094 20090914 DNB 73.93 74.9 73.74 74.67 5485 20090915 DNB 74.83 74.9 74.17 74.6 3541 20090916 DNB 74.46 74.82 74.02 74.76 3705 20090917 DNB 74.84 75.17 74.24 74.38 6057 20090918 DNB 74.86 74.86 74.02 74.26 4839 20090921 DNB 73.8 74.27 73.7 74.02 4500 20090922 DNB 73.83 74.41 73.78 74.32 3546 20090923 DNB 74.3 74.45 73.83 73.83 3920 20090924 DNB 74.19 74.37 73.76 74.03 4098 20090925 DNB 74 74.59 73.46 73.9 4841 20090928 DNB 73.87 74.69 73.69 74.42 3820 20090929 DNB 74.65 74.88 74.07 74.82 4810 20090930 DNB 74.47 75.49 74 75.32 5178 20091001 DNB 75 75 73.91 73.97 4501 20091002 DNB 73.45 74.09 73.18 73.26 3438 20091005 DNB 73.18 73.79 73.01 73.78 4376 20091006 DNB 73.98 74.86 73.59 74.58 2896 20091007 DNB 74.44 74.58 74.05 74.44 2455 20091008 DNB 74.87 75.76 74.64 75.3 2452 20091009 DNB 75.65 75.75 75.27 75.52 3041 20091012 DNB 75.49 75.7399 74.93 75.33 1733 20091013 DNB 74.93 75.01 74.46 74.78 1720 20091014 DNB 75.27 75.84 74.72 75.71 3934 20091015 DNB 75.69 75.99 75.2 75.95 3681 20091016 DNB 75.74 76.32 75.37 75.99 2760 20091019 DNB 76.22 76.945 75.92 76.82 1933 20091020 DNB 76.56 77.8 75.94 77.66 8088 20091021 DNB 77.55 77.99 77.25 77.35 4053 20091022 DNB 77.72 78.84 76.99 78.7 3960 20091023 DNB 78.56 79.1 78.34 78.75 4755 20091026 DNB 78.64 80.41 78.49 80.11 6557 20091027 DNB 80.35 81.26 80.24 80.43 6106 20091028 DNB 80.49 80.73 78.16 78.41 7853 20091105 DNB 77.53 79.35 77.53 79.31 3697 20091106 DNB 79.31 79.36 78.46 79.31 2901 20091109 DNB 79.42 81.36 79.22 81.34 3159 20091110 DNB 80.75 81.4 80.68 80.81 2955 20091111 DNB 81.13 81.43 80.46 80.81 2421 20091112 DNB 80.87 81.24 80.43 80.54 2127 20091113 DNB 80.82 81.77 80.33 80.8 1741 20091116 DNB 80.99 81.75 80.81 81.4 3338 20091117 DNB 81.4 81.68 81.2 81.4 2915 20091118 DNB 81.13 81.64 80.43 80.68 3196 20091119 DNB 80.61 80.88 79.44 79.99 2832 20091120 DNB 79.94 80 79.44 79.87 2348 20091123 DNB 80.1 81.03 80.1 80.5 1991 20091124 DNB 80.14 80.58 79.69 79.92 2168 20091125 DNB 79.92 80.21 79.7 79.96 2502 20091127 DNB 78.7 79.63 78.12 78.67 1313 20091130 DNB 78.66 78.81 77.89 78.59 4269 20091201 DNB 78.58 79.24 78.55 79 2511 20091202 DNB 79.07 79.64 78.75 79.05 3169 20091203 DNB 78.94 79.52 78.54 78.63 2554 20091204 DNB 79.61 79.99 79.24 79.93 3076 20091207 DNB 80.01 81.36 79.72 80.6 3518 20091208 DNB 80.16 81.41 79.9 80.38 3473 20091209 DNB 80.25 80.81 79.85 80.71 2871 20091210 DNB 81 82.54 80.92 82.29 4211 20091211 DNB 82.29 82.61 81.45 81.85 3201 20091214 DNB 82.28 82.53 81.91 82.45 2648 20091215 DNB 82.06 82.23 81.71 82.13 3432 20091216 DNB 82.27 82.55 81.97 82.25 3011 20091217 DNB 82.24 82.44 81.83 82.11 4628 20091218 DNB 82.3 82.3 81 82.02 6914 20091221 DNB 82.4 82.81 81.93 82.51 2941 20091222 DNB 82.81 82.81 82.37 82.79 2824 20091223 DNB 83 83.35 82.84 83.19 1186 20091224 DNB 83.22 83.68 83.22 83.68 490 20091228 DNB 83.75 84.03 83.68 83.9 1258 20091229 DNB 84.29 84.83 84.18 84.54 1608 20091230 DNB 84.43 84.95 84.35 84.64 1506 20091231 DNB 84.5 84.91 84.31 84.37 2208 20100104 DNB 84.61 84.61 82.95 83.37 4994 20100105 DNB 83.16 83.41 82.7 83.29 4134 20100106 DNB 82.93 83.54 82.73 83.34 3636 20100107 DNB 83.01 83.52 82.33 82.6 3567 20100108 DNB 82.34 82.47 81.42 81.74 3233 20100111 DNB 82.17 82.32 81.66 82.15 2615 20100112 DNB 81.73 82.42 81.57 82.07 1693 20100113 DNB 82.09 82.48 81.96 82.29 2250 20100114 DNB 82.08 82.5 81.78 82.43 2646 20100115 DNB 82.54 82.54 82.09 82.15 3390 20100119 DNB 82.35 82.65 82.05 82.6 1781 20100120 DNB 82.22 82.25 81.36 81.39 2858 20100121\n\n---\n\n15.1 15.16 14.86 14.87 192241 20100326 DELL 14.95 15 14.7 14.99 219025 20100329 DELL 15.1 15.2 14.92 14.96 120520 20100330 DELL 14.88 15.0696 14.832 14.97 124612 20100331 DELL 14.97 15.18 14.94 15.02 150498 20100401 DELL 15.04 15.19 14.92 15.05 139880 20100405 DELL 15.03 15.31 15 15.2 180900 20100406 DELL 15.1 15.63 15.1 15.57 295991 20100407 DELL 15.56 15.97 15.55 15.69 342419 20100408 DELL 15.52 15.78 15.425 15.76 223617 20100409 DELL 15.66 15.85 15.44 15.83 230560 20100412 DELL 15.78 15.99 15.77 15.93 221152 20100413 DELL 15.88 15.91 15.61 15.72 189759 20100414 DELL 15.97 16.685 15.96 16.56 576847 20100415 DELL 16.5 16.93 16.5 16.86 377477 20100416 DELL 16.93 17 16.63 16.76 420239 20100419 DELL 16.69 16.92 16.59 16.898 227750 20100420 DELL 16.93 17.04 16.6113 17.01 254324 20100421 DELL 17.1 17.2 16.95 17.17 241001 20100422 DELL 16.95 17.5 16.77 17.46 347483 20100423 DELL 17.37 17.52 17.24 17.5 220718 20100426 DELL 17.37 17.41 16.96 17.02 335800 20100427 DELL 16.87 16.98 16.5 16.53 307642 20100428 DELL 16.28 16.58 16.17 16.51 358713 20100429 DELL 16.55 16.7 16.44 16.65 197606 20100430 DELL 16.57 16.75 16.18 16.2 306242 20100503 DELL 16.29 16.46 16.21 16.38 235405 20100504 DELL 16.22 16.28 15.46 15.66 379276 20100505 DELL 15.56 15.98 15.48 15.77 271002 20100506 DELL 15.7 15.95 14.28 15.2 387187 20100507 DELL 15.1 15.4 14.62 15.01 444162 20100511 DELL 15.21 15.83 15.14 15.48 248219 20100512 DELL 15.56 15.8 15.51 15.72 229568 20100513 DELL 15.6 15.96 15.41 15.44 210809 20100514 DELL 15.33 15.39 14.93 15.15 218821 20100517 DELL 15.2 15.31 14.87 15.22 268941 20100518 DELL 15.33 15.45 14.9 15 213033 20100519 DELL 15.04 15.2 14.67 14.98 216003 20100520 DELL 14.63 14.65 14.27 14.32 455533 20100521 DELL 13.5 15 13.12 13.35 1015124 20100524 DELL 13.41 13.87 13.36 13.44 439819 20100526 DELL 13.44 13.63 13.24 13.25 346992 20100527 DELL 13.53 13.71 13.32 13.4 315485 20100528 DELL 13.47 13.53 13.19 13.33 217035 20100601 DELL 13.24 13.51 13.08 13.09 211150 20100602 DELL 13.13 13.28 12.9304 13.12 293408 20100603 DELL 13.24 13.96 13.23 13.7625 543109 20100604 DELL 13.34 13.52 13.15 13.24 300297 20100607 DELL 13.2 13.34 12.93 12.93 224392 20100608 DELL 12.94 13.02 12.56 12.68 388501 20100609 DELL 12.81 13.07 12.42 12.78 424612 20100610 DELL 13.01 13.1 12.87 13.07 225008 20100611 DELL 12.8 13.22 12.78 13.15 191039 20100614 DELL 13.3 13.44 13.04 13.09 205866 20100615 DELL 13.22 14.11 13.2 14 418732 20100616 DELL 13.87 14.06 13.77 13.99 226611 20100617 DELL 14.2 14.26 13.81 14.2 301265 20100618 DELL 14.27 14.28 13.94 14.04 205640 20100621 DELL 14.17 14.28 13.86 13.95 226079 20100622 DELL 14 14.2 13.76 13.8025 201894 20100623 DELL 13.82 13.96 13.61 13.82 214114 20100624 DELL 13.77 13.81 12.88 12.93 649121 20100625 DELL 13.07 13.12 12.65 12.9325 487941 20100628 DELL 12.99 13.12 12.87 12.95 303599 20100629 DELL 12.64 12.65 12.2 12.27 385016 20100630 DELL 12.23 12.46 12 12.06 273440 20100701 DELL 12.14 12.41 11.9 12.03 366715 20100702 DELL 12.05 12.14 11.9125 12.03 158142 20100707 DELL 11.85 12.48 11.83 12.4575 264398 20100708 DELL 12.57 12.79 12.47 12.78 261233 20100709 DELL 12.78 12.91 12.63 12.85 188557 20100712 DELL 12.75 13.03 12.7 12.84 150557 20100713 DELL 12.86 13.29 12.76 13.2 233600 20100714 DELL 13.4 13.86 13.4 13.52 288583 20100715 DELL 13.59 13.73 13.321 13.64 229069 20100716 DELL 13.61 13.74 13.04 13.065 232277 20100719 DELL 13.1 13.48 13.04 13.44 163825 20100720 DELL 13.15 13.38 13.01 13.36 208227 20100721 DELL 13.26 13.45 13.05 13.07 259295 20100722 DELL 13.31 13.52 13.18 13.4 211632 20100723 DELL 13.34 13.53 13.27 13.51 129470 20100726 DELL 13.48 13.76 13.45 13.74 102343 20100727 DELL 13.85 13.95 13.625 13.66 107014 20100728 DELL 13.6 13.73 13.42 13.5 86258 20100729 DELL 13.55 13.69 13.025 13.16 236332 20100730 DELL 13.04 13.37 13.01 13.24 141302 20100802 DELL 13.43 13.68 13.35 13.61 104059 20100803 DELL 13.55 13.6 13.34 13.42 91235 20100804 DELL 13.48 13.53 13.07 13.21 203854 20100805 DELL 13.08 13.22 12.87 13.13 253347 20100806\n\n---\n\n14.01 33411 20091203 MAS 14.05 14.31 13.97 14.18 48984 20091204 MAS 14.48 14.67 14.15 14.6 48573 20091207 MAS 14.51 14.64 13.84 13.91 45972 20091208 MAS 13.8 13.9 13.49 13.55 95818 20091209 MAS 13.62 13.65 13.19 13.47 25597 20091210 MAS 13.54 13.755 13.44 13.54 24507 20091211 MAS 13.795 13.795 13.35 13.55 24190 20091214 MAS 13.68 13.79 13.49 13.71 16624 20091215 MAS 13.61 13.77 13.46 13.56 21135 20091216 MAS 13.84 14.04 13.63 13.95 29149 20091217 MAS 13.81 13.9 13.66 13.72 21784 20091218 MAS 13.79 14.07 13.37 13.39 52225 20091221 MAS 13.51 13.87 13.51 13.75 30522 20091222 MAS 13.83 13.97 13.76 13.86 40708 20091223 MAS 13.94 14.15 13.85 14.13 27870 20091224 MAS 14.2 14.36 14.15 14.36 6984 20091228 MAS 14.48 14.48 13.9905 14.08 15528 20091229 MAS 14.13 14.16 13.77 14.01 22046 20091230 MAS 13.97 13.99 13.7 13.93 22137 20091231 MAS 13.89 14 13.79 13.81 24057 20100104 MAS 13.97 14.3 13.88 14.29 29705 20100105 MAS 14.2 14.43 14.12 14.42 28634 20100106 MAS 14.45 14.75 14.31 14.57 64244 20100107 MAS 14.56 15.57 14.51 15.48 84373 20100108 MAS 15.33 15.6 15 15.58 36123 20100111 MAS 15.71 15.75 15.36 15.54 28026 20100112 MAS 15.37 15.44 15.14 15.3 21662 20100113 MAS 15.34 15.35 14.85 15.1 33542 20100114 MAS 15.02 15.16 14.75 15.03 27769 20100115 MAS 15.32 15.34 14.86 15 55566 20100119 MAS 14.98 15.44 14.92 15.42 26992 20100120 MAS 15.02 15.12 14.73 14.95 30602 20100121 MAS 15.1 15.1 14.39 14.49 40096 20100122 MAS 14.41 14.74 13.9 13.91 33360 20100125 MAS 14.13 14.27 13.74 13.78 33919 20100126 MAS 13.69 14.08 13.62 13.78 44976 20100127 MAS 13.63 13.68 13.21 13.58 63034 20100128 MAS 13.68 13.99 13.33 13.6 48385 20100129 MAS 13.7 14.06 13.48 13.56 65539 20100201 MAS 13.69 14 13.56 13.99 37257 20100202 MAS 13.96 14.8 13.94 14.78 53058 20100203 MAS 14.66 15 14.66 14.85 46821 20100204 MAS 14.64 14.65 14.26 14.5 67753 20100205 MAS 14.41 14.49 13.6 14.14 56167 20100208 MAS 14.09 14.23 13.85 14.05 32373 20100209 MAS 14.34 14.62 14.07 14.45 46548 20100210 MAS 14.46 14.5925 14.07 14.5 31375 20100211 MAS 13.84 14.08 12.78 13.77 128226 20100212 MAS 13.49 13.81 13.35 13.81 71434 20100216 MAS 13.9 14.06 13.71 14 42476 20100217 MAS 14.12 14.12 13.75 13.95 45162 20100218 MAS 13.95 14.04 13.761 13.83 37194 20100219 MAS 13.77 13.81 13.56 13.6 62581 20100222 MAS 13.69 13.95 13.6 13.62 36899 20100223 MAS 13.68 13.72 13.045 13.25 46675 20100224 MAS 13.3 13.36 12.91 13.31 33789 20100225 MAS 13 13.19 12.7601 13.16 43800 20100226 MAS 13.22 13.45 13.01 13.37 48175 20100301 MAS 13.47 14.005 13.47 13.97 45516 20100302 MAS 14.11 14.13 13.9 14.02 27815 20100303 MAS 14.13 14.44 13.99 14.17 32560 20100304 MAS 14.18 14.35 14.01 14.14 19159 20100305 MAS 14.28 14.425 14.25 14.39 19273 20100308 MAS 14.43 14.66 14.4 14.66 21639 20100309 MAS 14.59 14.75 14.51 14.68 24474 20100310 MAS 14.64 14.96 14.62 14.86 35630 20100311 MAS 14.77 15.17 14.65 15.12 36722 20100312 MAS 15.2 15.32 14.96 15.17 30944 20100315 MAS 15.16 15.23 14.97 15.15 28161 20100316 MAS 15.2 15.35 15.07 15.31 24491 20100317 MAS 15.34 15.74 15.3 15.53 32709 20100318 MAS 15.47 15.75 15.42 15.51 23211 20100319 MAS 15.55 15.75 15 15 58149 20100322 MAS 14.85 15.26 14.82 15.23 28325 20100323 MAS 15.23 15.52 15.04 15.48 41121 20100324 MAS 15.5 15.66 15.13 15.17 40392 20100325 MAS 15.37 15.48 15.11 15.13 34641 20100326 MAS 15.23 15.4 15.045 15.19 27866 20100329 MAS 15.28 15.45 15.13 15.32 26264 20100330 MAS 15.32 15.59 15.3 15.4 17038 20100331 MAS 15.29 15.66 15.0801 15.52 53990 20100401 MAS 15.68 15.95 15.63 15.81 43077 20100405 MAS 15.91 16.22 15.71 16.15 31736 20100406 MAS 16.07 16.33 15.92 16.28 35030 20100407 MAS 16.16 16.22 15.72 15.85 43063 20100408 MAS 15.8 15.96 15.56 15.89 39639 20100409 MAS 15.9 16.12 15.81 16.1 29068 20100412 MAS 16.18 16.18 15.91 16.11 32088 20100413 MAS 16.03 16.22 16.02 16.14 24914 20100414 MAS 16.23 16.91 16.18 16.88 42258 20100415 MAS 16.81 17.4 16.68 17 62629 20100416 MAS 17.44 17.72 16.82 16.96 72317 20100419 MAS 16.86 17.25 16.7 17.24 57164 20100420 MAS 17.38 17.67 17.26 17.49\n\n---\n\n16.43 16.54 15.85 16.5 167198 20100208 WU 16.53 16.55 16.14 16.16 147857 20100209 WU 16.35 16.51 15.93 16.14 194611 20100210 WU 16.14 16.6 16.01 16.44 157284 20100211 WU 16.3 16.41 16.1 16.16 157815 20100212 WU 16.14 16.32 15.96 16.12 103030 20100216 WU 16.36 16.6 16.12 16.5 95556 20100217 WU 16.5 16.71 16.4 16.4 46418 20100218 WU 16.4 16.52 16.39 16.46 46256 20100219 WU 16.39 16.46 16.27 16.35 69631 20100222 WU 16.38 16.4 16.12 16.18 87056 20100223 WU 16.29 16.315 16.04 16.04 75706 20100224 WU 16.13 16.17 15.96 16 79066 20100225 WU 15.85 16.04 15.71 15.96 86718 20100226 WU 16.01 16.02 15.72 15.78 73908 20100301 WU 15.88 16.07 15.76 16 77322 20100302 WU 16.28 16.29 15.81 15.84 89304 20100303 WU 15.91 15.99 15.71 15.71 71497 20100304 WU 15.77 16.1 15.68 16.02 99277 20100305 WU 16.16 16.34 16.02 16.31 68465 20100308 WU 16.34 16.37 16.18 16.22 57369 20100309 WU 16.18 16.37 16.04 16.33 90195 20100310 WU 16.35 16.54 16.15 16.51 96406 20100311 WU 16.48 16.83 16.395 16.77 78274 20100312 WU 16.86 16.92 16.69 16.91 55757 20100315 WU 16.86 16.89 16.59 16.71 87102 20100316 WU 16.44 16.81 16.17 16.24 156679 20100317 WU 16.3 16.85 16.25 16.8 100281 20100318 WU 16.84 16.865 16.65 16.8 64541 20100319 WU 16.87 16.93 16.57 16.66 79759 20100322 WU 16.58 16.96 16.58 16.91 61887 20100323 WU 16.92 17.17 16.9 17.06 68676 20100324 WU 17.02 17.04 16.8 16.88 58659 20100325 WU 17.04 17.23 16.94 16.97 127809 20100326 WU 17.08 17.08 16.92 17.05 50758 20100329 WU 17.16 17.26 17.1 17.19 37813 20100330 WU 17.25 17.27 16.91 17 52737 20100331 WU 16.98 17.09 16.9 16.96 74017 20100401 WU 17.1 17.4 16.94 17.06 69689 20100405 WU 17.13 17.46 17.08 17.37 66806 20100406 WU 17.35 17.65 17.35 17.5 75675 20100407 WU 17.41 17.58 17.18 17.24 66216 20100408 WU 17.21 17.51 17.12 17.41 62757 20100409 WU 17.4 17.55 17.34 17.49 53839 20100412 WU 17.51 17.76 17.43 17.47 52738 20100413 WU 17.37 17.54 17.3 17.49 45569 20100414 WU 17.58 17.73 17.44 17.64 59069 20100415 WU 17.61 17.73 17.5 17.53 55816 20100416 WU 17.48 17.5825 17.15 17.24 58437 20100419 WU 17.17 17.43 17.17 17.3 69093 20100420 WU 17.4 17.46 17.265 17.4 52640 20100421 WU 17.37 17.46 17.3 17.44 60879 20100422 WU 17.25 17.5 17.23 17.45 82361 20100423 WU 17.42 17.78 17.37 17.78 51030 20100426 WU 17.87 18.23 17.81 17.91 148850 20100427 WU 18.85 19.57 18.85 19 328364 20100428 WU 19.02 19.09 18.36 18.62 150514 20100429 WU 18.7 18.94 18.45 18.68 85543 20100430 WU 18.67 18.79 18.21 18.25 116641 20100503 WU 18.4 18.46 18.18 18.22 76098 20100504 WU 18.03 18.03 17.61 17.78 111053 20100505 WU 17.6 17.89 17.46 17.58 54561 20100506 WU 17.46 17.65 16.3 17.22 150122 20100507 WU 17.15 17.26 16.35 16.55 153206 20100510 WU 17.24 17.38 17.09 17.24 113358 20100511 WU 17.16 17.16 16.6 16.79 91761 20100512 WU 16.84 17.13 16.75 17.06 75156 20100513 WU 16.98 17.26 16.98 17.01 84978 20100514 WU 16.94 17.01 16.5295 16.64 111585 20100517 WU 16.67 16.92 16.35 16.62 90215 20100518 WU 16.79 16.9 16.15 16.19 96706 20100519 WU 16.26 16.37 16.02 16.05 142447 20100520 WU 15.74 15.95 15.38 15.47 111394 20100521 WU 15.2 15.92 15.2 15.9 112103 20100524 WU 15.8 15.89 15.58 15.58 57744 20100525 WU 15.24 15.7 15.1505 15.69 92385 20100526 WU 15.69 16.07 15.6 15.66 106373 20100527 WU 15.91 16.28 15.82 16.26 73018 20100528 WU 16.25 16.32 15.9 15.96 54417 20100601 WU 15.78 16.1 15.68 15.69 84075 20100602 WU 15.8 15.86 15.66 15.76 88875 20100603 WU 15.82 16.16 15.79 16.15 68671 20100604 WU 15.76 16 15.59 15.63 100250 20100607 WU 15.73 15.82 15.27 15.31 92919 20100608 WU 15.39 15.44 15.1 15.44 88904 20100609 WU 15.5 15.79 15.35 15.51 66814 20100610 WU 15.72 16.08 15.72 16.07 65891 20100611 WU 15.87 16.1 15.87 16.09 52091 20100614 WU 16.24 16.31 15.91 15.93 52444 20100615 WU 16.1 16.38 16.07 16.38 88547 20100616 WU 16.26 16.35 16.1 16.23 48425 20100617 WU 16.31 16.34 16.11 16.27 30563 20100618 WU 16.23 16.35 16.15 16.2 47364 20100621 WU 16.4 16.5 15.92 16 44432 20100622 WU 16 16.08 15.76 15.78 47891 20100623 WU 15.71 15.89 15.505 15.8 45359 20100624 WU 15.73\n\n---\n\nAGN 60.69 60.83 60.13 60.36 12153 20091214 AGN 60.82 61.95 60.66 61.71 18194 20091215 AGN 61.65 61.83 61.055 61.74 12228 20091216 AGN 61.76 61.89 60.85 60.92 17258 20091217 AGN 60.47 61.31 59.835 60.34 10971 20091218 AGN 60.41 60.835 59.7 60.64 20460 20091221 AGN 61.18 61.99 61.09 61.5 12170 20091222 AGN 61.79 62.5 60.78 62.26 12789 20091223 AGN 62.1 62.74 62.1 62.6 10671 20091224 AGN 62.83 62.97 62.42 62.64 6154 20091228 AGN 62.58 63.5 62.58 63.45 12143 20091229 AGN 63.43 64.08 63.28 63.61 13955 20091230 AGN 62.88 63.49 62.1 63.49 12923 20091231 AGN 63.5 63.68 63 63.01 9412 20100104 AGN 63.56 63.74 62.6 63.32 17448 20100105 AGN 63.12 63.67 62.62 62.85 12516 20100106 AGN 62.67 63.11 62.24 62.46 21291 20100107 AGN 62.23 62.4 61.02 61.12 25853 20100108 AGN 60.85 61.045 60.045 60.47 26506 20100111 AGN 60.56 60.67 60.05 60.64 18336 20100112 AGN 60.34 60.48 59.86 60.12 14962 20100113 AGN 60.34 60.49 58.92 59.87 25525 20100114 AGN 59.85 60.43 59.52 60.19 14575 20100115 AGN 60.37 60.85 59.95 60.04 24970 20100119 AGN 60.17 61.79 59.9 61.74 25642 20100120 AGN 61.46 61.98 60.51 61.2 20432 20100121 AGN 61.31 61.38 59.69 59.75 19502 20100122 AGN 59.49 60.06 58.68 58.71 20101 20100125 AGN 58.93 59.15 58.17 58.46 16751 20100126 AGN 58.27 58.5899 57.75 58.14 12029 20100127 AGN 57.97 59.0975 57.65 58.99 16308 20100128 AGN 59.17 59.2 57.66 57.66 18697 20100129 AGN 57.89 58.01 57.01 57.5 21060 20100201 AGN 57.69 58.07 57.38 58.02 18886 20100202 AGN 58.13 58.47 56.08 56.96 50877 20100203 AGN 56.64 57.2325 56.07 56.77 33547 20100204 AGN 55.35 59.36 55.25 57.39 71432 20100205 AGN 57.08 58.36 56.99 58.03 45467 20100208 AGN 57.91 58.66 57.43 58.17 25055 20100209 AGN 58.59 59.35 58.27 58.75 23361 20100210 AGN 58.8 58.89 57.78 58.48 17583 20100211 AGN 58.41 59.86 58.12 59.67 19067 20100212 AGN 59.23 59.47 58.46 59.45 19757 20100216 AGN 59.82 59.95 59.28 59.85 12863 20100217 AGN 60.1 60.1 59.6 59.74 11455 20100218 AGN 59.46 59.65 59.06 59.62 10862 20100219 AGN 59.46 59.74 58.98 59.53 11395 20100222 AGN 59.52 59.52 58.61 59.13 13294 20100223 AGN 58.96 59.2 58.09 58.23 13249 20100224 AGN 58.47 58.865 58.25 58.82 9480 20100225 AGN 58.6 58.73 57.75 58.72 12460 20100226 AGN 58.75 58.89 58.3 58.43 13373 20100301 AGN 58.59 60 58.4 59.61 17878 20100302 AGN 59.955 60.38 59.73 60.13 17132 20100303 AGN 60.37 60.6 59.58 59.67 8576 20100304 AGN 59.79 60.21 59.67 60.1 10418 20100305 AGN 61.04 62.15 60.94 62.1 20656 20100308 AGN 62.05 62.05 61.33 61.54 14248 20100309 AGN 61.28 61.61 60.99 61.35 9945 20100310 AGN 62.6 62.78 61.9 62.11 23722 20100311 AGN 61.88 62.11 61.15 62.11 15120 20100312 AGN 62.12 62.35 61.01 62.31 15655 20100315 AGN 62.15 62.85 61.94 62.84 19431 20100316 AGN 62.93 63.05 62.4 62.97 10455 20100317 AGN 62.91 63.82 62.87 63.81 15703 20100318 AGN 63.73 63.745 62.88 63.69 11696 20100319 AGN 63.84 64.86 63.57 64 24149 20100322 AGN 63.88 64.69 63.76 64.36 10681 20100323 AGN 64.42 64.51 64 64.39 11744 20100324 AGN 64.06 64.35 63.89 64.1 14427 20100325 AGN 64.51 65.05 64 64.06 23204 20100326 AGN 64.15 64.33 64 64.12 13570 20100329 AGN 64.24 64.79 64.14 64.42 15393 20100330 AGN 64.32 64.95 64.21 64.9 17351 20100331 AGN 64.62 65.79 64.335 65.32 25353 20100401 AGN 65.55 65.87 65.02 65.25 15062 20100405 AGN 65.34 65.53 65.08 65.17 14181 20100406 AGN 64.92 65.14 64.42 64.48 24444 20100407 AGN 64.08 64.11 62.82 63.15 31880 20100408 AGN 63.22 63.69 63 63.55 23085 20100409 AGN 63.61 63.74 63.11 63.33 16826 20100412 AGN 63.45 63.76 63.08 63.17 12142 20100413 AGN 63.19 63.22 62.58 62.73 19331 20100414 AGN 62.63 62.91 62.13 62.53 20126 20100415 AGN 62.34 62.68 62.05 62.36 19863 20100416 AGN 62.19 62.54 61.41 61.71 23861 20100419 AGN 62.61 63.58 62.43 63.2 23429 20100420 AGN 63.43 64.65 63.1 64.44 26019 20100421 AGN 64.51 64.51 62.28 62.55 24073 20100422 AGN 62.44 62.5 61.3675 62 22313 20100423 AGN 61.84 62.45 61.43 62.4 15348 20100426 AGN 62.44 62.85 61.79 61.8 14490 20100427 AGN 61.49 62.48 60.36 60.41 21184 20100428 AGN 60.71 61.42 60.71 60.95 15815 20100429 AGN\n\n---\n\n25.04 121507 20100604 TXN 24.66 24.95 24.07 24.1775 145425 20100607 TXN 24.32 24.56 23.605 23.67 168834 20100608 TXN 23.99 24 23.09 23.88 191134 20100609 TXN 24.3 24.54 23.64 23.74 198828 20100610 TXN 24.2 24.57 24.04 24.53 173087 20100611 TXN 24.27 24.59 24.15 24.45 139429 20100614 TXN 24.74 24.89 24.505 24.57 146041 20100615 TXN 24.75 25.76 24.53 25.7 177404 20100616 TXN 25.33 25.6 25.1 25.42 193052 20100617 TXN 25.69 25.69 25.21 25.53 100562 20100618 TXN 25.51 25.69 25.27 25.45 120382 20100621 TXN 25.76 25.85 25.11 25.25 111238 20100622 TXN 25.34 25.58 24.69 24.75 119284 20100623 TXN 24.88 25.1 24.47 24.78 114484 20100624 TXN 24.6 24.75 24.17 24.28 147246 20100625 TXN 24.22 24.43 23.86 24.04 261271 20100628 TXN 24.16 24.5029 24.02 24.36 116704 20100629 TXN 24.05 24.09 23.68 23.89 194089 20100630 TXN 24.01 24.07 23.155 23.28 174784 20100701 TXN 23.21 23.47 22.65 23.17 164401 20100702 TXN 23.3 23.39 22.71 23.11 113369 20100706 TXN 23.37 23.54 22.935 23.12 134752 20100707 TXN 23.2 24.27 23.15 24.25 168523 20100708 TXN 24.42 24.47 23.86 24.22 106708 20100709 TXN 24.38 24.51 24.17 24.48 76985 20100712 TXN 24.36 24.8 24.36 24.75 98224 20100713 TXN 25.08 25.54 24.95 25.39 152120 20100714 TXN 25.58 25.8 24.96 25.09 175930 20100715 TXN 25.07 25.45 24.75 25.4 141226 20100716 TXN 25.2 25.43 24.73 24.77 120036 20100719 TXN 24.87 25.58 24.87 25.55 155059 20100720 TXN 24.16 24.89 24.01 24.77 309339 20100721 TXN 24.77 24.92 24.4 24.5 152498 20100722 TXN 24.67 25.42 24.65 25.29 156360 20100723 TXN 25.25 25.46 25 25.38 125157 20100726 TXN 25.28 25.66 25.09 25.66 95690 20100727 TXN 25.79 25.92 25.47 25.58 131525 20100728 TXN 25.42 25.62 25.1 25.22 119580 20100729 TXN 25.35 25.4 24.64 24.88 121899 20100730 TXN 24.59 24.88 24.25 24.69 131517 20100802 TXN 24.65 25.23 24.41 25.11 91193 20100803 TXN 25.07 25.1 24.7 24.81 92040 20100804 TXN 24.82 25.25 24.62 25.18 106723 20100805 TXN 25.07 25.53 24.9 25.4 134111 20100806 TXN 25.2 25.6 25.06 25.46 120034 20100809 TXN 25.55 25.85 25.35 25.7 89194 20100810 TXN 25.38 25.54 24.97 25.35 154172 20100811 TXN 25.01 25.14 24.86 24.97 127472 20100812 TXN 24.3 24.97 24.22 24.41 181362 20100813 TXN 24.29 24.69 24.24 24.28 98361 20100816 TXN 24.18 24.59 24.03 24.53 101808 20100817 TXN 24.8 24.87 24.65 24.7 99308 20100819 TXN 24.85 25.05 24.45 24.53 94494 20100820 TXN 24.44 24.87 24.44 24.7 125890 20090821 TXT 14.31 14.82 14.23 14.58 45236 20090824 TXT 14.71 15.07 14.52 14.75 56599 20090825 TXT 14.91 15 14.65 14.8 58474 20090826 TXT 14.73 15.71 14.68 15.64 117460 20090827 TXT 15.64 15.78 15.15 15.52 65617 20090828 TXT 15.74 15.8 15.33 15.67 63314 20090831 TXT 15.48 15.52 15.19 15.36 45652 20090901 TXT 16.11 16.69 15.5 15.5 124781 20090902 TXT 16.4 17.76 15.92 17.39 238593 20090903 TXT 17.68 17.72 16.34 16.86 132742 20090904 TXT 16.81 17.24 16.5 17.07 58235 20090909 TXT 18.14 18.789 18 18.41 107293 20090910 TXT 18.53 19.09 18.35 19.02 79966 20090911 TXT 19.55 20 18.93 19.02 128897 20090914 TXT 18.84 19.33 18.65 19.27 80881 20090915 TXT 19.41 20.58 19.135 20.55 146774 20090916 TXT 20.85 20.99 19.91 20.15 107409 20090917 TXT 20.17 20.84 19.18 19.4 107824 20090918 TXT 19.42 19.68 19.15 19.44 73975 20090921 TXT 19.07 19.4 18.58 19.25 61067 20090922 TXT 19.51 19.6517 19.1 19.37 61233 20090923 TXT 19.28 19.37 18.6 19.2 73556 20090924 TXT 19.25 19.34 18.11 18.34 67822 20090925 TXT 17.51 18.16 17.3 17.88 101209 20090928 TXT 18.3 18.89 18.06 18.59 46842 20090929 TXT 18.68 18.89 18.1 18.71 54389 20090930 TXT 18.76 19.25 18.4 18.98 83710 20091001 TXT 18.81 18.98 18.12 18.15 72058 20091002 TXT 17.5 17.95 17.39 17.51 73017 20091005 TXT 18.08 18.46 17.77 18.45 40629 20091006 TXT 18.7 19.31 18.5 18.72 52483 20091007 TXT 18.69 18.87 18.44 18.7 25149 20091008 TXT 18.9 19.49 18.9 19.38 33587 20091009 TXT 19.28 19.57 19 19.49 30221 20091012 TXT 19.6 20 19.48 19.6 27789 20091013 TXT 19.51 19.59 19.1 19.15 37679 20091014 TXT 19.54 20.15 19.39 20.07 52575 20091015 TXT 20.03 20.34 19.61 20.34 44449 20091016 TXT 20.09 20.39 19.55 19.92\n\n---\n\nNOC 59.72 59.95 59.4 59.94 19530 20100218 NOC 59.72 61.51 59.66 61.51 32925 20100219 NOC 61.09 61.79 60.94 61.21 27664 20100222 NOC 61.22 62.05 61.18 61.67 17273 20100223 NOC 61.48 62.23 61.21 61.24 17613 20100224 NOC 61.47 62 61.18 61.69 18620 20100225 NOC 61.17 61.19 60.16 61.12 27651 20100226 NOC 61.14 61.42 60.36 61.26 34120 20100301 NOC 61.34 63.23 61.15 63.01 24483 20100302 NOC 62.96 63.6675 62.8 62.91 21228 20100303 NOC 62.94 63.03 61.95 62.32 24929 20100304 NOC 62.29 63.3 62.08 63.08 34225 20100305 NOC 63.42 64.36 63.38 64.22 13783 20100308 NOC 64.16 64.44 63.75 64.16 12725 20100309 NOC 63.96 64.52 63.69 64 18313 20100310 NOC 63.86 64.71 63.78 64.55 14181 20100311 NOC 64.55 64.8 63.87 64.75 13024 20100312 NOC 64.73 64.97 63.85 64 18720 20100315 NOC 63.98 64.37 63.8 64.31 17393 20100316 NOC 64.43 64.89 64.29 64.63 15572 20100317 NOC 64.88 65.34 64.56 64.9 14871 20100318 NOC 65.03 65.1 64.73 65.05 14973 20100319 NOC 65.19 65.61 64.91 65.54 43421 20100322 NOC 65.26 65.37 64.8 64.94 21508 20100323 NOC 65.05 65.325 64.83 65.19 21434 20100324 NOC 65.14 65.35 64.73 64.94 16909 20100325 NOC 65.42 65.6 64.94 64.98 15688 20100326 NOC 65.02 65.68 65.02 65.53 17588 20100329 NOC 65.72 66.056 65.52 65.78 20192 20100330 NOC 65.95 65.95 65.35 65.72 14266 20100331 NOC 65.39 65.88 65.19 65.57 19694 20100401 NOC 66.05 66.61 65.79 66.25 15818 20100405 NOC 66.45 66.69 66.19 66.42 13809 20100406 NOC 66.2 66.2 65.54 65.73 14334 20100407 NOC 65.4 65.9 65.14 65.22 20072 20100408 NOC 65.18 65.265 64.64 65.1 16578 20100409 NOC 65.08 66.19 65.07 66.15 18137 20100412 NOC 66.15 66.63 66.095 66.22 13888 20100413 NOC 66.05 66.79 65.6 66.64 17772 20100414 NOC 66.84 66.86 65.84 66.85 13776 20100415 NOC 66.64 67 66.34 66.82 13210 20100416 NOC 66.72 66.8291 65.43 65.97 17347 20100419 NOC 65.68 66.5 65.6 66.42 13482 20100420 NOC 66.62 67.61 66.47 67.43 16203 20100421 NOC 67.17 68.39 66.94 68.37 15057 20100422 NOC 67.96 69.07 67.79 68.99 18474 20100423 NOC 69.04 69.04 68.15 68.99 11429 20100426 NOC 69.04 69.63 68.85 68.93 16073 20100427 NOC 68.77 68.77 67.1 67.18 19962 20100428 NOC 69.47 69.8 67.75 68.67 33330 20100429 NOC 68.98 69.75 68.4 69.38 17920 20100430 NOC 69.31 69.7199 67.77 67.83 20244 20100503 NOC 68.22 69.38 68.11 69.24 13654 20100504 NOC 68.48 68.48 66.22 66.66 21487 20100505 NOC 66.2 67.11 66.2 66.88 15673 20100506 NOC 66.6 66.72 60.34 64.57 25525 20100507 NOC 64.34 64.68 62.34 62.84 27969 20100510 NOC 64.85 65.43 63.73 64.8775 28427 20100511 NOC 63.72 65.7 63.42 64.89 18880 20100512 NOC 64.89 65.88 64.83 65.75 10892 20100513 NOC 65.49 65.94 64.79 64.98 9073 20100514 NOC 64.42 64.79 62.79 63.29 14532 20100517 NOC 63.21 64.09 62.38 63.67 14900 20100518 NOC 64.18 64.58 62.84 62.85 17643 20100519 NOC 62.49 62.97 61.38 62.27 19684 20100520 NOC 61.12 61.47 59.67 60.02 25378 20100521 NOC 59.03 61.18 58.56 61.13 30336 20100524 NOC 60.81 61.48 60.18 60.25 21205 20100525 NOC 58.89 60.99 58.7 60.8 40465 20100526 NOC 61.31 61.68 60.09 60.18 34276 20100527 NOC 60.7 61.06 60.21 61.03 22411 20100528 NOC 61.16 61.37 60.27 60.49 21035 20100601 NOC 60.17 61.11 59.5 59.54 20309 20100602 NOC 59.72 60.87 59.66 60.82 26540 20100603 NOC 61.05 61.97 60.67 60.93 18542 20100604 NOC 59.65 59.91 58.04 58.24 18948 20100607 NOC 58.36 58.37 57.06 57.09 23035 20100608 NOC 56.73 57.46 56.33 57.38 20723 20100609 NOC 57.63 58.69 57.32 57.56 18782 20100610 NOC 58.41 59.17 58.24 59.05 15413 20100611 NOC 58.43 59.74 58.12 59.69 16210 20100614 NOC 60.17 60.71 59.62 59.74 18864 20100615 NOC 59.92 60.62 59.74 60.5 26963 20100616 NOC 60.41 61.27 60.33 61.08 22161 20100617 NOC 61.73 61.88 60.81 61.5 17581 20100618 NOC 61.56 62.16 61.44 62.08 20192 20100621 NOC 62.95 63.06 61 61.24 19835 20100622 NOC 61.1 61.67 60.12 60.25 18620 20100623 NOC 60.11 60.52 59.45 59.93 16025 20100624 NOC 59.73 60.06 58.7 58.88 20446 20100625 NOC 59.02 59.06 58.05 58.6 25155 20100628 NOC 58.81 59.39 58.26 58.42 21787 20100629 NOC 57.6 57.85 55.21 55.52 35725 20100630 NOC 55.19 55.78 54.37 54.44 37896\n\n---\n\n37.2 59470 20091217 JEC 37.01 37.23 36.75 37.09 23188 20091218 JEC 37.41 38.04 37.26 37.74 29301 20091221 JEC 38.18 38.18 37.42 37.74 17215 20091222 JEC 37.67 38.43 37.63 38.14 16013 20091223 JEC 38.19 38.52 37.91 38.48 18153 20091224 JEC 38.49 38.99 38.48 38.68 5965 20091228 JEC 38.65 38.97 38.36 38.49 10961 20091229 JEC 38.64 38.76 38.41 38.49 9651 20091230 JEC 38.47 38.47 37.75 37.92 10939 20091231 JEC 37.95 38.24 37.57 37.61 10460 20100104 JEC 38.1 38.46 37.93 38.45 17284 20100105 JEC 38.45 39 38.23 38.96 15102 20100106 JEC 38.85 40.3 38.8 40.25 25796 20100107 JEC 40.46 41.94 40.4355 41.84 34675 20100108 JEC 41.52 42.0798 41.42 41.74 19176 20100111 JEC 41.97 42.2198 41.26 41.31 15104 20100112 JEC 40.91 41.39 40.33 41.19 15583 20100113 JEC 41.15 41.42 40.02 40.93 15923 20100114 JEC 40.92 41.36 40.675 41.09 10566 20100115 JEC 40.9 41.31 40.04 40.27 15575 20100119 JEC 40.32 40.59 40.04 40.59 14880 20100120 JEC 40.2 40.25 39.6 40.14 20658 20100121 JEC 40.08 40.3 39.37 39.9 31641 20100122 JEC 39.71 40.4422 39.1805 39.66 35113 20100125 JEC 39.88 40.28 39.55 39.95 25945 20100126 JEC 41.09 41.09 38.89 38.94 23597 20100127 JEC 39.54 39.9 38.7602 39.42 24510 20100128 JEC 39.69 39.74 37.88 38.08 22873 20100129 JEC 38.19 39.19 37.68 37.79 17930 20100201 JEC 38.05 38.38 37.92 38.31 18520 20100202 JEC 37.22 37.9 36.8 37.35 32224 20100203 JEC 37.86 38.45 37.36 37.57 18715 20100204 JEC 37.17 37.38 36.17 36.18 17500 20100205 JEC 36.22 36.3 35.02 35.93 23398 20100208 JEC 36.01 36.85 35.39 36.23 19740 20100209 JEC 36.74 37.11 36.1801 36.7 17837 20100210 JEC 36.72 36.84 36.0708 36.29 13260 20100211 JEC 36.25 36.86 36.06 36.8 15059 20100212 JEC 36.34 36.57 35.87 36.5 13144 20100216 JEC 37 38.36 36.85 38.27 22953 20100217 JEC 38.59 38.81 38.19 38.74 13430 20100218 JEC 38.58 39.4399 38.58 39.36 9807 20100219 JEC 39.11 39.5 38.86 39.32 13837 20100222 JEC 39.51 39.68 39.1105 39.32 8895 20100223 JEC 39.13 39.26 38.55 38.87 17646 20100224 JEC 38.81 39.71 38.81 39.47 17087 20100225 JEC 38.86 39.45 38.44 39.4 13173 20100226 JEC 39.24 39.48 38.71 38.8 18613 20100301 JEC 38.91 39.71 38.91 39.43 11884 20100302 JEC 39.64 39.96 39.5299 39.87 14743 20100303 JEC 39.95 40.8 39.88 40.31 16523 20100304 JEC 40.35 40.56 40.03 40.19 9516 20100305 JEC 40.38 41.44 40.38 41.44 18354 20100308 JEC 41.93 42.97 41.85 42.01 19697 20100309 JEC 42.87 43.5 42.39 42.85 22693 20100310 JEC 42.87 43.26 42.73 42.9 13656 20100311 JEC 42.72 43.365 42.38 43.25 11703 20100312 JEC 43.45 43.69 43.1301 43.55 8888 20100315 JEC 43.55 43.64 42.73 43.43 9970 20100316 JEC 43.49 44 43.26 43.97 11044 20100317 JEC 44.15 45.04 44.15 44.43 18851 20100318 JEC 44.31 44.43 43.41 43.85 11846 20100319 JEC 43.88 44.2099 42.98 43.1 16867 20100322 JEC 42.94 43.605 42.73 43.4 8542 20100323 JEC 43.51 44.37 43.35 44.24 11121 20100324 JEC 44.9 46.13 44.9 45.97 34284 20100325 JEC 46.11 46.3 45.3 45.41 15948 20100326 JEC 45.49 45.5999 44.6299 44.87 12568 20100329 JEC 45.05 45.74 44.94 45.65 11408 20100330 JEC 45.61 45.87 45.14 45.41 12312 20100331 JEC 45.2 45.51 45 45.19 10306 20100401 JEC 45.52 46.07 45.429 45.77 10521 20100405 JEC 45.97 46.4 45.78 46.17 11687 20100406 JEC 45.88 46.26 45.275 45.41 26147 20100407 JEC 45.155 45.69 43.87 44.37 27867 20100408 JEC 44.09 44.43 43.83 44.28 18456 20100409 JEC 44.36 48.2799 44.18 47.61 97657 20100412 JEC 47.36 47.36 46.44 46.74 21660 20100413 JEC 46.71 47.48 46.62 47.35 20092 20100414 JEC 47.58 47.94 47.12 47.86 12157 20100415 JEC 47.7 48.24 47.5 47.91 9562 20100416 JEC 47.77 47.8 46.25 46.9 17834 20100419 JEC 46.7 47.19 46.11 46.77 13834 20100420 JEC 47.22 47.85 46.76 47.57 10649 20100421 JEC 47.66 48.34 47.4 48.13 11225 20100422 JEC 47.71 48.9 46.92 48.85 12029 20100423 JEC 48.9 49.44 48.49 49.21 12761 20100426 JEC 49.605 49.7 48.2 48.67 18374 20100427 JEC 46.9 50.68 46.08 47.46 38415 20100428 JEC 47.86 49.16 47.86 48.38 17451 20100429 JEC 49.05 50.02 48.85 49.97 15576 20100430 JEC 50.12 50.2 48.12 48.22 18082 20100503 JEC 48.66 49.29 48.16 49.13 16006 20100504 JEC\n\n---\n\nSEE 19.8 20.1 19.75 20.04 7041 20091014 SEE 20.27 20.54 20.14 20.4 7739 20091015 SEE 20.24 20.5 20.15 20.48 7890 20091016 SEE 20.4 20.45 19.98 20.22 6534 20091019 SEE 20.21 20.59 20.14 20.55 6137 20091020 SEE 21.18 21.35 20.755 20.94 12219 20091021 SEE 20.94 21.29 20.45 20.49 11210 20091022 SEE 20.54 20.71 20.3 20.68 9808 20091023 SEE 20.72 20.72 20.02 20.24 9708 20091026 SEE 20.23 20.58 19.7 19.9 8356 20091027 SEE 20.01 20.38 19.8 19.86 13998 20091028 SEE 21.25 21.38 19.33 19.6 32659 20091105 SEE 20.35 20.98 20.35 20.95 18801 20091106 SEE 20.81 21.15 20.71 20.96 11140 20091109 SEE 21.18 21.9 21.17 21.88 12952 20091110 SEE 21.81 21.97 21.72 21.8 13092 20091111 SEE 22 22.25 21.81 21.98 16459 20091112 SEE 22 22.35 21.6 21.65 14140 20091113 SEE 21.57 21.83 21.51 21.8 18831 20091116 SEE 21.91 22.54 21.91 22.41 14564 20091117 SEE 22.4 22.6 22.1509 22.53 11274 20091118 SEE 22.52 22.67 22.3 22.46 10740 20091119 SEE 22.13 22.31 21.85 22.12 8070 20091120 SEE 21.88 22.28 21.83 22.15 9008 20091123 SEE 22.52 22.82 22.48 22.59 9262 20091124 SEE 22.67 22.81 22.35 22.42 8416 20091125 SEE 22.46 22.82 22.41 22.65 10151 20091127 SEE 22.15 22.48 21.93 22.31 4266 20091130 SEE 22.24 22.42 22.07 22.29 9936 20091201 SEE 22.52 22.59 22.345 22.5 12473 20091202 SEE 22.44 22.75 22.38 22.65 13529 20091203 SEE 22.63 22.79 22.25 22.33 10835 20091204 SEE 22.75 22.99 22.27 22.62 11315 20091207 SEE 22.55 22.89 22.48 22.65 6648 20091208 SEE 22.58 22.6 22.26 22.39 9664 20091209 SEE 22.41 22.51 22.13 22.45 8564 20091210 SEE 22.61 22.71 22.28 22.32 10595 20091211 SEE 22.46 22.51 22.11 22.3 8475 20091214 SEE 22.39 22.39 22.18 22.27 10257 20091215 SEE 22.19 22.3 21.95 22.05 9208 20091216 SEE 22.09 22.28 21.94 22.06 7568 20091217 SEE 21.95 22.02 21.68 21.79 6829 20091218 SEE 21.88 21.98 21.45 21.75 14471 20091221 SEE 21.84 22.145 21.81 21.83 7793 20091222 SEE 21.83 22.03 21.66 21.69 10999 20091223 SEE 21.79 21.92 21.58 21.85 8857 20091224 SEE 21.91 22.24 21.9 22.2 2780 20091228 SEE 22.27 22.42 21.8 21.99 8377 20091229 SEE 22 22.2 21.97 22.09 5591 20091230 SEE 21.97 22.09 21.87 21.87 5835 20091231 SEE 21.95 22.11 21.76 21.86 7693 20100104 SEE 22.01 22.1 21.92 22.02 9203 20100105 SEE 21.99 22.08 21.63 21.79 8313 20100106 SEE 21.78 21.84 21.27 21.37 13343 20100107 SEE 21.34 21.62 21.25 21.59 13948 20100108 SEE 21.55 21.7 21.46 21.68 7028 20100111 SEE 21.81 21.94 21.55 21.67 6389 20100112 SEE 21.44 21.53 21.23 21.5 7246 20100113 SEE 21.46 21.61 21.25 21.5 5899 20100114 SEE 21.51 21.53 21.17 21.32 9132 20100115 SEE 21.26 21.32 21.08 21.12 8764 20100119 SEE 21.15 21.68 21.04 21.66 15749 20100120 SEE 21.56 21.59 21.2 21.35 10264 20100121 SEE 21.32 21.55 20.91 20.94 12995 20100122 SEE 20.82 21.03 20.41 20.44 13205 20100125 SEE 20.72 20.89 19.67 20.07 29799 20100126 SEE 19.91 20.36 19.79 20.07 19520 20100127 SEE 19.95 20.29 19.61 20.19 22578 20100128 SEE 20.32 20.32 19.68 19.77 17457 20100129 SEE 19.86 20.25 19.74 19.84 20208 20100201 SEE 19.97 20.19 19.69 19.9 20159 20100202 SEE 19.95 20.21 19.79 20.12 15589 20100203 SEE 19.94 20.06 19.42 19.68 13109 20100204 SEE 19.51 19.52 18.84 18.84 11821 20100205 SEE 18.86 19.07 18.43 19.05 14651 20100208 SEE 19.03 19.24 18.76 19.12 29294 20100209 SEE 19.41 19.67 19.12 19.44 17355 20100210 SEE 19.38 19.48 19.05 19.33 13711 20100211 SEE 19.3 19.63 19.18 19.62 19492 20100212 SEE 19.34 19.61 19.13 19.57 11547 20100216 SEE 19.71 19.79 19.6 19.74 10366 20100217 SEE 19.81 20.21 19.64 19.86 10968 20100218 SEE 19.8 20.19 19.76 20.12 7874 20100219 SEE 20.1 20.28 19.88 20.17 8129 20100222 SEE 20.24 20.31 20.04 20.27 8320 20100223 SEE 20.18 20.38 19.98 20.1 9713 20100224 SEE 20.11 20.33 20.04 20.31 7747 20100225 SEE 20.11 20.48 19.73 20.45 11373 20100226 SEE 20.52 20.53 20.16 20.43 15843 20100301 SEE 20.49 20.65 20.39 20.65 11787 20100302 SEE 20.75 20.85 20.62 20.78 10548 20100303 SEE 20.82 20.9 20.73 20.85 9386 20100304 SEE 20.81 20.9 20.31 20.53 14691 20100305 SEE 20.73 20.94 20.62 20.91 12077 20100308 SEE 20.93 21.14 20.74 20.88 13096 20100309\n\n---\n\n9.1 8.57 9.09 18684 20100611 NYT 8.95 9.23 8.93 9.18 10066 20100614 NYT 9.42 9.44 9.1 9.14 21276 20100615 NYT 9.29 9.76 9.22 9.76 16238 20100616 NYT 9.64 9.81 9.46 9.68 21348 20100617 NYT 9.81 9.9 9.58 9.89 15185 20100618 NYT 9.9 10 9.71 9.78 23204 20100621 NYT 9.96 10.46 9.96 10.13 26547 20100622 NYT 10.16 10.27 10 10.04 13403 20100623 NYT 10.03 10.09 9.58 9.62 16601 20100624 NYT 9.52 9.61 9.17 9.18 13037 20100625 NYT 9.2 9.69 9.07 9.4 39473 20100628 NYT 9.5 9.88 9.41 9.74 20413 20100629 NYT 9.49 9.6 8.93 9 14137 20100630 NYT 8.95 9.18 8.59 8.65 18097 20100701 NYT 8.64 8.82 8.38 8.64 16650 20100702 NYT 8.69 8.75 8.43 8.5 13811 20100706 NYT 8.65 8.88 8.5 8.57 20833 20100707 NYT 8.55 8.67 8.42 8.54 33181 20100708 NYT 8.68 9.1 8.61 8.94 23522 20100709 NYT 8.9 9.07 8.77 9.01 19021 20100712 NYT 9.01 9.48 8.98 9.39 24480 20100713 NYT 9.54 9.58 9.34 9.52 19051 20100714 NYT 9.51 9.62 9.39 9.59 14721 20100715 NYT 9.58 9.65 9.3 9.58 17623 20100716 NYT 9.52 9.52 8.75 8.8 23439 20100719 NYT 8.82 9.2 8.62 8.88 18242 20100720 NYT 8.7 9.37 8.6 9.34 25221 20100721 NYT 9.41 9.54 8.98 9.05 14154 20100722 NYT 9.37 9.55 8.92 9.16 32301 20100723 NYT 9.11 9.31 8.94 9.25 16162 20100726 NYT 9.26 9.75 9.22 9.74 19157 20100727 NYT 9.85 9.9 9.61 9.76 13183 20100728 NYT 9.7 9.7 8.97 8.99 25455 20100729 NYT 9.04 9.24 8.6 8.71 28695 20100730 NYT 8.56 8.91 8.21 8.74 25928 20100802 NYT 8.96 9.38 8.88 9.32 17762 20100803 NYT 9.22 9.31 8.88 8.9 12986 20100804 NYT 8.97 9.1 8.88 9.04 7275 20100805 NYT 8.95 9.02 8.865 8.98 8626 20100806 NYT 8.85 8.91 8.595 8.73 12829 20100809 NYT 8.8 8.97 8.67 8.71 7232 20100810 NYT 8.52 8.6 8.37 8.45 18258 20100811 NYT 8.26 8.44 8 8.03 17197 20100812 NYT 7.79 8.06 7.65 7.85 20572 20100813 NYT 7.83 7.98 7.669 7.71 12874 20100816 NYT 7.65 7.89 7.62 7.79 11931 20100817 NYT 7.9 8.22 7.78 8.1 18310 20100819 NYT 8.25 8.3 7.9 7.95 14467 20100820 NYT 7.85 7.89 7.59 7.72 11469 20090821 NYX 28.06 28.18 27.67 27.93 27067 20090824 NYX 28.13 28.37 27.62 27.68 29183 20090825 NYX 27.65 28.13 27.65 27.96 30513 20090826 NYX 27.8 28.83 27.76 28.79 34415 20090827 NYX 28.55 28.73 28.17 28.52 25638 20090828 NYX 28.68 28.69 28.04 28.46 18179 20090831 NYX 27.85 28.38 27.73 28.34 28077 20090901 NYX 28.11 28.24 27.04 27.1 44641 20090902 NYX 26.98 27.44 26.84 27.03 25544 20090903 NYX 27.25 27.4 26.94 27.32 20750 20090904 NYX 27.15 27.66 26.9 27.61 22686 20090909 NYX 28.07 28.35 27.75 28.28 27773 20090910 NYX 28.19 28.3 27.81 28.21 20776 20090911 NYX 28.14 28.14 27.74 27.78 30457 20090914 NYX 27.51 28.36 27.27 28.32 28040 20090915 NYX 28.47 29.56 28.25 29.23 38288 20090916 NYX 29.59 29.59 28.95 29.56 40270 20090917 NYX 29.41 30.14 29.28 29.84 37369 20090918 NYX 29.91 30.44 29.53 30.29 42690 20090921 NYX 29.92 30.09 29.25 29.42 29501 20090922 NYX 29.93 29.93 29.39 29.82 33211 20090923 NYX 29.8 29.99 29.05 29.15 28146 20090924 NYX 29.29 29.4699 28.0799 28.44 28328 20090925 NYX 28.19 28.45 27.83 28.02 23517 20090928 NYX 28.01 28.83 27.87 28.78 23907 20090929 NYX 28.76 29.15 28.61 28.74 16899 20090930 NYX 29.34 29.34 28.42 28.89 24753 20091001 NYX 28.9 28.9 27.72 27.76 26998 20091002 NYX 27.19 27.9 27.19 27.31 21909 20091005 NYX 27.54 28.18 27.4 28.13 26608 20091006 NYX 28.3 28.39 27.54 28.05 23106 20091007 NYX 27.83 28.74 27.7 28.71 30995 20091008 NYX 28.8 29.04 28.23 28.4 29853 20091009 NYX 28.26 28.38 27.72 28.11 27396 20091012 NYX 28.23 28.5 28.05 28.48 18908 20091013 NYX 28.32 28.5 28.06 28.32 16812 20091014 NYX 28.66 30 28.6508 29.9 57686 20091015 NYX 29.59 29.96 29.59 29.94 32368 20091016 NYX 29.51 29.83 29.12 29.2 34368 20091019 NYX 29.32 29.32 28.88 29.06 32343 20091020 NYX 29.09 29.25 28.66 28.97 31841 20091021 NYX 28.96 29.68 28.76 28.81 30632 20091022 NYX 28.85 29.35 28.59 29.33 28094 20091023 NYX 29.35 29.57 29.08 29.15 29169 20091026 NYX 29.24 29.79 28.16 28.26 37846 20091027 NYX 28.24 28.46 27.64 27.76 27989 20091028 NYX 27.6 27.88 26.82 26.83 36948 20091105 NYX 25.75 26.22 25.67 26.17 21978 20091106 NYX 25.92 27.18 25.88 26.87 33261 20091109\n\n---\n\nSTJ 38.22 38.69 37.88 38.46 18865 20100811 STJ 38.03 38.05 37.18 37.28 17932 20100812 STJ 37.05 37.52 36.8 37.44 14716 20100813 STJ 37.3 37.52 37.21 37.23 11866 20100816 STJ 37.06 37.15 36.8 36.9 14050 20100817 STJ 37.14 37.79 37.04 37.56 11966 20100819 STJ 37.73 37.73 36.68 37.17 18540 20100820 STJ 36.88 37 36.13 36.58 20315 20090821 STR 34.24 34.9 33.9 34.79 14511 20090824 STR 35.01 35.53 34.9 35.18 11701 20090825 STR 35.36 35.54 34.65 34.78 8491 20090826 STR 34.36 34.92 34.14 34.65 5349 20090827 STR 34.43 34.6 33.6 34.42 7890 20090828 STR 34.58 35.02 34.27 34.9 12594 20090831 STR 34.14 34.25 33.47 33.76 8344 20090901 STR 33.53 34.29 33.14 33.26 10580 20090902 STR 33.04 33.5 32.95 33.16 10409 20090903 STR 33.43 33.43 32.72 33.01 8990 20090904 STR 33.04 33.52 32.96 33.48 6982 20090909 STR 34.3 34.67 34.02 34.38 11943 20090910 STR 34.38 35.33 34.14 35.22 11996 20090911 STR 35.3 36.06 35.23 35.65 12984 20090914 STR 34.01 35.42 33.76 35.25 11587 20090915 STR 35.39 35.76 35.26 35.67 9023 20090916 STR 35.91 36.9 35.64 36.88 13047 20090917 STR 36.91 37.51 36.69 37.04 12831 20090918 STR 37.42 37.42 36.48 36.85 20282 20090921 STR 36 36.35 35.21 36.11 10933 20090922 STR 36.66 37.49 36.46 37.24 16446 20090923 STR 37.23 37.3625 36.28 36.36 12323 20090924 STR 36.45 36.58 35.64 35.99 11807 20090925 STR 35.78 36.35 35.75 36.16 14139 20090928 STR 36.23 36.99 36.2 36.89 10781 20090929 STR 36.91 37.72 36.69 37.59 12502 20090930 STR 37.51 37.89 36.92 37.56 18640 20091001 STR 37.59 37.59 35.74 35.74 16626 20091002 STR 35.2 35.74 34.98 35.45 12049 20091005 STR 35.44 36.95 35.37 36.88 15356 20091006 STR 37.32 37.99 37.17 37.58 12460 20091007 STR 37.42 37.77 37.25 37.64 7974 20091008 STR 37.88 38.9 37.68 38.89 16509 20091009 STR 38.52 38.8 38.41 38.64 13574 20091012 STR 39 39.47 38.87 39.01 8811 20091013 STR 39.01 39.15 38.22 39.04 11899 20091014 STR 39.48 39.71 38.98 39.3 12379 20091015 STR 39.1 40.91 39.01 40.89 19713 20091016 STR 40.54 41.13 40.48 40.86 15330 20091019 STR 40.87 42.26 40.68 42.16 13027 20091020 STR 41.98 42.33 41.54 42.22 17530 20091021 STR 41.96 43.46 41.95 42.35 17210 20091022 STR 42.35 42.42 41.7601 42.02 14729 20091023 STR 42.14 42.43 40.79 41.15 12768 20091026 STR 41.17 42.17 40.24 40.39 15846 20091027 STR 40.64 41.43 40.28 40.59 9934 20091028 STR 41.2 42.06 39.83 39.94 26904 20091105 STR 40.75 41.18 40.34 41.01 10297 20091106 STR 40.65 41.27 40.29 40.65 8961 20091109 STR 41.74 42.79 41.74 42.28 17753 20091110 STR 41.93 42.77 41.93 42.52 17106 20091111 STR 42.84 43.15 42.35 42.59 16352 20091112 STR 42.47 43 41.95 42.04 25262 20091113 STR 42.23 42.65 41.66 42.23 12768 20091116 STR 42.68 43.2 42.53 43.01 12425 20091117 STR 42.94 42.95 42.47 42.56 10027 20091118 STR 42.25 42.5 41.38 41.49 12269 20091119 STR 41.25 41.4 39.94 40.18 11201 20091120 STR 39.83 40.15 39.18 39.59 19016 20091123 STR 40.41 40.93 39.92 40.17 9220 20091124 STR 40.04 40.17 38.96 39.49 17242 20091125 STR 39.65 40.67 39.315 40.35 13454 20091127 STR 39.34 39.83 38.88 39.35 4678 20091130 STR 39.38 39.81 39.17 39.67 12891 20091201 STR 40.24 40.79 40.13 40.5 9209 20091202 STR 40.55 41.1897 40.55 40.77 10169 20091203 STR 40.91 41.19 40.15 40.22 8827 20091204 STR 40.95 41.17 39.43 40.01 14232 20091207 STR 39.91 40.35 39.5 39.57 17629 20091208 STR 39.14 39.17 37.94 38.13 19939 20091209 STR 38.15 38.41 37.5119 38.09 11852 20091210 STR 38.44 39.03 38.27 38.75 12441 20091211 STR 38.95 39.37 38.87 39.22 14864 20091214 STR 39.79 40.7 39.76 40.54 13312 20091215 STR 40.41 40.82 40.17 40.6 7607 20091216 STR 40.91 41.14 40.53 40.88 9786 20091217 STR 40.74 41.36 40.2 41.26 16581 20091218 STR 41.76 42.081 41.37 41.59 18415 20091221 STR 41.92 42.41 41.86 42.33 10057 20091222 STR 42.23 42.6 41.909 42.13 8964 20091223 STR 42.26 42.66 42 42.5 5725 20091224 STR 42.49 42.83 42.43 42.8 2412 20091228 STR 43.26 43.26 42.7 43.03 5533 20091229 STR 43.1 43.2137 42.75 42.85 6125 20091230 STR 42.81 42.81 42.03 42.23 6563 20091231 STR 42.47 42.56 41.5 41.57 4839 20100104 STR 42.57 43.26\n\n---\n\n22.99 23.37 160352 20100609 LOW 23.53 23.7601 23.16 23.28 116867 20100610 LOW 23.57 23.86 23.4 23.84 123065 20100611 LOW 23.59 23.83 23.23 23.48 104957 20100614 LOW 23.68 23.9075 23.39 23.45 100970 20100615 LOW 23.65 23.93 23.2 23.93 99645 20100616 LOW 23.67 23.73 22.95 23.2 182355 20100617 LOW 23.24 23.26 22.36 22.68 223206 20100618 LOW 22.7 22.97 22.53 22.62 301223 20100621 LOW 22.81 22.98 22.44 22.51 134612 20100622 LOW 22.665 22.73 21.73 21.76 202842 20100623 LOW 21.71 22.12 21.42 21.85 139783 20100624 LOW 21.35 21.625 21.06 21.24 159024 20100625 LOW 21.21 21.6 21.12 21.33 212729 20100628 LOW 21.38 21.49 21.17 21.23 80098 20100629 LOW 20.94 20.98 20.5 20.6 166783 20100630 LOW 20.58 20.86 20.36 20.42 113430 20100701 LOW 20.52 20.76 20.02 20.41 225985 20100702 LOW 20.53 20.54 20.01 20.27 119216 20100706 LOW 20.44 20.64 19.74 19.96 160622 20100707 LOW 20.04 20.42 19.64 20.39 185841 20100708 LOW 20.54 20.64 20.04 20.23 143875 20100709 LOW 20.22 20.44 20.02 20.43 197086 20100712 LOW 20.36 20.5 20.11 20.36 172376 20100713 LOW 20.55 21.305 20.47 21.16 177748 20100714 LOW 21.09 21.09 20.64 20.87 111204 20100715 LOW 20.89 20.95 20.5 20.88 95841 20100716 LOW 20.79 20.79 19.99 20.04 147780 20100719 LOW 20.03 20.06 19.75 19.93 82188 20100720 LOW 19.71 20.42 19.64 20.33 115111 20100721 LOW 20.4 20.41 19.86 19.98 101414 20100722 LOW 20.2 20.93 20.17 20.83 138123 20100723 LOW 20.76 21.14 20.59 21.11 122497 20100726 LOW 21.23 21.82 21.08 21.8 126023 20100727 LOW 21.91 21.99 21.04 21.15 149932 20100728 LOW 21.08 21.31 20.57 20.7 112100 20100729 LOW 20.98 21.01 20.13 20.48 145010 20100730 LOW 20.31 20.81 20.19 20.74 116941 20100802 LOW 21.05 21.4 20.81 21.33 93576 20100803 LOW 21.16 21.28 20.65 20.74 119300 20100804 LOW 20.92 21.13 20.81 20.81 112620 20100805 LOW 20.72 20.94 20.47 20.74 109540 20100806 LOW 20.52 20.62 20.2 20.28 156744 20100809 LOW 20.39 20.46 20.29 20.31 109914 20100810 LOW 20.16 20.19 19.82 19.92 134298 20100811 LOW 19.74 19.92 19.35 19.81 191072 20100812 LOW 19.58 19.83 19.45 19.74 99409 20100813 LOW 19.62 20.06 19.55 19.59 138054 20100816 LOW 20.08 20.3697 19.58 19.7 259945 20100817 LOW 20.01 20.34 19.78 19.99 182105 20100819 LOW 20.62 20.845 20.13 20.4 178239 20100820 LOW 20.27 20.72 20.18 20.64 120403 20090821 LSI 4.94 5.06 4.89 5.05 77193 20090824 LSI 5.07 5.2 5.05 5.08 55204 20090825 LSI 5.08 5.16 4.99 5.07 60206 20090826 LSI 5.05 5.15 5 5.08 42306 20090827 LSI 5.07 5.22 5 5.2 61521 20090828 LSI 5.23 5.45 5.23 5.29 64552 20090831 LSI 5.2 5.26 5.12 5.21 52538 20090901 LSI 5.17 5.38 5.02 5.04 76044 20090902 LSI 5.02 5.1 4.91 4.94 85101 20090903 LSI 4.97 5.01 4.93 5.01 32580 20090904 LSI 5.01 5.16 4.99 5.16 38915 20090909 LSI 5.37 5.53 5.3 5.38 100094 20090910 LSI 5.38 5.58 5.34 5.53 84444 20090911 LSI 5.54 5.56 5.415 5.48 55652 20090914 LSI 5.42 5.59 5.38 5.58 56156 20090915 LSI 5.6 5.78 5.58 5.69 90916 20090916 LSI 5.69 5.75 5.51 5.53 110743 20090917 LSI 5.49 5.55 5.41 5.47 78234 20090918 LSI 5.51 5.56 5.38 5.45 71154 20090921 LSI 5.39 5.45 5.3 5.34 72996 20090922 LSI 5.43 5.52 5.32 5.47 58321 20090923 LSI 5.58 5.62 5.45 5.46 78412 20090924 LSI 5.53 5.53 5.27 5.3 64011 20090925 LSI 5.45 5.64 5.3 5.58 125164 20090928 LSI 5.61 5.7 5.56 5.65 50806 20090929 LSI 5.61 5.72 5.44 5.46 84808 20090930 LSI 5.49 5.61 5.35 5.49 80427 20091001 LSI 5.45 5.49 5.29 5.31 122493 20091002 LSI 5.25 5.36 5.17 5.22 88933 20091005 LSI 5.27 5.49 5.23 5.46 92468 20091006 LSI 5.51 5.61 5.48 5.54 96440 20091007 LSI 5.53 5.62 5.48 5.58 61889 20091008 LSI 5.65 5.66 5.37 5.44 140711 20091009 LSI 5.55 5.67 5.48 5.67 126626 20091012 LSI 5.62 5.84 5.58 5.71 137981 20091013 LSI 5.71 5.85 5.65 5.79 134262 20091014 LSI 5.98 6.06 5.9 5.96 156742 20091015 LSI 5.93 5.96 5.69 5.75 101231 20091016 LSI 5.67 5.75 5.52 5.63 109994 20091019 LSI 5.72 5.77 5.57 5.73 110598 20091020 LSI 5.79 5.83 5.64 5.68 64299 20091021 LSI 5.62 5.77 5.5 5.51 87070 20091022 LSI 5.57 5.58 5.4 5.46 112487 20091023 LSI 5.56 5.63 5.31 5.35 103364 20091026 LSI 5.3 5.54 5.26 5.33 79343\n\n---\n\n16.51 16.64 16.05 16.06 81022 20100322 GCI 16.01 16.49 15.74 16.42 38887 20100323 GCI 16.49 16.8 16.19 16.72 30814 20100324 GCI 16.59 16.64 16.29 16.55 32863 20100325 GCI 16.62 16.96 16.47 16.5 33481 20100326 GCI 16.56 16.885 16.33 16.54 26462 20100329 GCI 16.67 17 16.52 16.72 29556 20100330 GCI 16.73 16.92 16.675 16.86 27969 20100331 GCI 16.8 16.8906 16.43 16.52 33025 20100401 GCI 16.44 16.8 16.42 16.7 26426 20100405 GCI 16.79 17.3 16.72 17.24 28073 20100406 GCI 17.15 17.539 17.03 17.34 41813 20100407 GCI 17.21 17.83 17.12 17.52 63429 20100408 GCI 17.4 17.9 17.12 17.79 43814 20100409 GCI 17.77 18.0199 17.67 17.79 34032 20100412 GCI 17.8 18.15 17.5 18.11 40277 20100413 GCI 17.95 18.04 17.66 17.74 36158 20100414 GCI 17.99 18.11 17.78 17.98 48134 20100415 GCI 17.93 18.545 17.76 18.14 61579 20100416 GCI 18.93 19.69 18 18.04 173981 20100419 GCI 18.11 18.28 17.26 17.81 83915 20100420 GCI 18 18.53 18 18.43 60700 20100421 GCI 18.51 18.73 18.29 18.42 55227 20100422 GCI 18.29 18.35 17.82 18.28 35992 20100423 GCI 18.3 18.41 18 18.28 36698 20100426 GCI 18.36 18.85 18.21 18.67 61713 20100427 GCI 18.46 18.56 17.47 17.56 63447 20100428 GCI 17.67 17.86 17.03 17.4 52864 20100429 GCI 17.58 17.63 17.29 17.5 54103 20100430 GCI 17.54 17.66 16.83 17.02 54484 20100503 GCI 17.14 17.4 16.995 17.29 60592 20100504 GCI 16.68 16.97 16.45 16.58 52086 20100505 GCI 16.27 16.7 15.92 16.29 40582 20100506 GCI 16.08 16.39 14.12 15.58 93252 20100507 GCI 15.5 15.62 14.33 15.05 116845 20100510 GCI 16.01 16.04 15.51 16.04 105287 20100511 GCI 15.7 17.2725 15.7 16.59 81192 20100512 GCI 16.65 17.15 16.44 17.07 48062 20100513 GCI 17.08 17.08 16.33 16.44 43387 20100514 GCI 16.24 16.34 15.4701 15.76 45444 20100517 GCI 15.8 16.45 15.58 16.19 50606 20100518 GCI 16.45 16.66 15.41 15.56 45868 20100519 GCI 15.41 15.52 14.7 15.3 54429 20100520 GCI 14.8 15.43 14.55 14.88 71465 20100521 GCI 14.54 15.04 14.38 14.58 84911 20100524 GCI 14.52 14.96 14.38 14.64 47797 20100525 GCI 14.08 14.71 13.93 14.7 54996 20100526 GCI 14.93 15.46 14.78 14.91 55608 20100527 GCI 15.42 15.88 15.24 15.86 32093 20100528 GCI 15.87 16.05 15.5 15.54 37606 20100601 GCI 15.27 15.36 14.52 14.54 55649 20100602 GCI 14.71 14.86 14.43 14.8 58042 20100603 GCI 14.93 15.09 14.47 14.85 34379 20100604 GCI 14.35 14.5 13.66 13.73 64696 20100607 GCI 13.87 14.45 13.48 14.29 122480 20100608 GCI 14.33 14.81 14.08 14.52 84025 20100609 GCI 14.75 15.11 14.42 14.53 67832 20100610 GCI 14.92 15.43 14.83 15.42 31113 20100611 GCI 15.18 16.07 15.18 16.04 40636 20100614 GCI 16.41 16.41 15.74 15.78 46658 20100615 GCI 16.05 16.645 15.97 16.61 27629 20100616 GCI 16.39 16.59 16.12 16.47 36355 20100617 GCI 16.62 16.62 16.05 16.41 33365 20100618 GCI 16.44 16.81 16.37 16.65 27161 20100621 GCI 16.98 17.22 16.44 16.56 34934 20100622 GCI 16.56 16.79 16.33 16.34 40362 20100623 GCI 16.32 16.41 15.72 15.88 44566 20100624 GCI 15.73 15.77 14.86 14.94 48077 20100625 GCI 15 15.04 14.64 14.88 39172 20100628 GCI 14.83 15.28 14.8 14.95 31194 20100629 GCI 14.65 14.72 13.84 14.04 49658 20100630 GCI 13.88 14.31 13.37 13.46 46066 20100701 GCI 13.31 13.51 12.54 13.36 78656 20100702 GCI 13.43 13.52 13.02 13.13 36036 20100706 GCI 13.35 13.71 12.97 13.13 39922 20100707 GCI 13.21 14.17 13.2 14.16 51740 20100708 GCI 14.36 14.53 14.17 14.49 33753 20100709 GCI 14.5 14.88 14.33 14.84 30608 20100712 GCI 14.79 14.935 14.305 14.62 40393 20100713 GCI 14.91 14.91 14.56 14.73 34483 20100714 GCI 14.67 14.97 14.38 14.77 54531 20100715 GCI 14.78 15.17 14.63 15.11 46613 20100716 GCI 14.63 14.68 13.39 13.5 128600 20100719 GCI 13.38 14 13.335 13.99 67691 20100720 GCI 13.64 14.19 13.52 14.12 56232 20100721 GCI 14.25 14.34 13.38 13.46 49683 20100722 GCI 13.76 13.88 13.31 13.48 60612 20100723 GCI 13.57 14.15 13.49 14.06 56332 20100726 GCI 14.09 14.81 14 14.52 54627 20100727 GCI 14.69 14.76 14.08 14.23 40648 20100728 GCI 14.185 14.37 13.77 13.9 28940 20100729 GCI 14.04 14.18 13.1 13.25 63195 20100730 GCI 13.02 13.275 12.88 13.18 39478 20100802 GCI 13.51 13.86 13.31 13.69 42775\n\n---\n\n49.12 49.14 21092 20090925 K 49.13 49.24 48.79 49.09 13976 20090928 K 49.22 49.76 49.01 49.62 17630 20090929 K 49.64 49.82 49.27 49.45 10776 20090930 K 49.49 49.49 48.8 49.23 17967 20091001 K 49.1 49.11 48.34 48.88 15669 20091002 K 48.84 48.86 48.45 48.66 12993 20091005 K 48.67 48.99 48.15 48.96 12740 20091006 K 49.12 49.69 48.97 49.3 14834 20091007 K 49.21 49.46 49.124 49.37 10994 20091008 K 49.5 49.77 49.345 49.74 18660 20091009 K 49.62 49.95 49.45 49.82 17085 20091012 K 49.9 49.98 49.47 49.68 13786 20091013 K 49.65 49.86 49.47 49.58 17195 20091014 K 49.72 49.76 49.3 49.58 19572 20091015 K 49.37 50.18 49.37 50.18 18539 20091016 K 49.89 50.67 49.78 50.48 26214 20091019 K 50.63 51.19 50.47 51.01 12787 20091020 K 51.03 51.32 50.56 50.68 17952 20091021 K 50.74 51.41 50.55 50.66 15326 20091022 K 50.715 50.87 50.09 50.64 17055 20091023 K 50.75 50.8 49.83 50.2 16667 20091026 K 50.3 51.11 50.1 50.45 19335 20091027 K 50.41 50.85 50.31 50.42 22638 20091028 K 50.2 50.78 49.87 49.99 28357 20091105 K 51.86 52.28 51.65 52.23 25153 20091106 K 52.1 52.42 51.83 52.2 19293 20091109 K 52.35 52.7 52.21 52.67 16021 20091110 K 52.49 53 52.49 52.82 16081 20091111 K 53.12 53.12 52.51 52.74 13443 20091112 K 52.82 53.04 52.65 52.96 17265 20091113 K 53.39 53.39 52.93 53.37 18794 20091116 K 53.45 53.8 53.21 53.39 23707 20091117 K 53.5 53.57 53.05 53.4 14664 20091118 K 53.31 53.49 52.9 53.34 11692 20091119 K 53.18 53.18 52.49 52.98 10742 20091120 K 53.03 53.47 52.89 53.12 19322 20091123 K 53.69 54 53.47 53.87 15866 20091124 K 53.79 54 53.49 53.91 16162 20091125 K 54.05 54.05 53.52 53.66 12570 20091127 K 52.86 53.13 52.63 52.97 9565 20091130 K 52.59 52.64 52.15 52.58 28666 20091201 K 52.7 53.2 52.66 52.97 17271 20091202 K 52.82 53.38 52.78 53 21660 20091203 K 52.99 53.09 52.58 52.73 21537 20091204 K 52.94 53.17 52.6 52.96 13309 20091207 K 53.07 53.17 52.78 52.89 14845 20091208 K 52.79 52.88 52.07 52.62 23138 20091209 K 52.65 52.96 52.55 52.8 19044 20091210 K 52.98 53.15 52.88 52.99 19212 20091211 K 53.01 53.97 53.01 53.7 22131 20091214 K 53.87 53.87 53.55 53.57 15271 20091215 K 53.64 53.65 53.08 53.12 20377 20091216 K 53.21 53.6 52.65 52.77 15708 20091217 K 52.75 52.75 52.07 52.14 15637 20091218 K 52.25 52.5 51.55 52.27 31794 20091221 K 52.27 52.48 52.11 52.17 15669 20091222 K 52.34 52.9 52.08 52.84 10675 20091223 K 53.14 53.5 53 53.3 15557 20091224 K 53.47 54.01 53.35 54 10351 20091228 K 53.91 53.97 53.715 53.96 6416 20091229 K 53.97 54.08 53.83 53.98 10684 20091230 K 53.95 54.1 53.6901 53.99 8079 20091231 K 53.96 53.96 53.17 53.2 7381 20100104 K 53.31 53.57 52.57 52.83 27489 20100105 K 52.8 52.98 52.55 52.95 14719 20100106 K 52.82 53.14 52.6 52.96 14942 20100107 K 52.78 53.52 52.7 53.48 17828 20100108 K 53.3 53.38 53 53.38 13426 20100111 K 53.51 53.72 53.03 53.41 9439 20100112 K 53.15 53.65 53.14 53.39 14637 20100113 K 53.46 53.99 53.46 53.72 14052 20100114 K 53.94 54.11 53.6 53.85 16383 20100115 K 54.5 54.96 54.1 54.34 37813 20100119 K 54.28 54.6 54.28 54.5 14372 20100120 K 54.08 54.43 53.5 53.87 18695 20100121 K 53.97 54.46 53.16 53.44 24010 20100122 K 53.28 54.61 53.24 54.34 48319 20100125 K 54.44 54.57 54.12 54.17 23397 20100126 K 54.06 54.86 53.82 54.85 29060 20100127 K 54.76 55.28 54.7 55.05 34845 20100128 K 55.03 55.45 54.14 54.81 24398 20100129 K 54.97 54.98 54.27 54.42 33342 20100201 K 54.79 54.88 54.34 54.72 33890 20100202 K 54.58 55.39 54.44 55.36 32712 20100203 K 55.3 55.41 54.9405 55.19 28370 20100204 K 53.82 54.43 52.41 52.41 65021 20100205 K 52.19 53.02 52.06 52.72 44629 20100208 K 52.82 52.82 51.99 52.01 21024 20100209 K 52.29 52.88 52.14 52.49 21925 20100210 K 52.55 52.62 52.2201 52.33 20018 20100211 K 52.41 52.66 51.93 52.62 19188 20100212 K 52.39 52.79 52.2 52.34 31789 20100216 K 52.6 52.68 51.91 52.6 25510 20100217 K 52.66 52.98 52.45 52.98 23045 20100218 K 53.04 53.12 52.78 53.01 14588 20100219 K 52.93 53.4 52.81 53.2 19851 20100222 K 53.15 53.32 52.74 52.86 25770 20100223 K 52.89 53.06 52.37 52.73 23446 20100224 K 52.8 53.32 52.15\n\n---\n\n.dir-locals.el\n.check.translations.R\n^\\.Rprofile$\n^data\\.table_.*\\.tar\\.gz$\n^config\\.log$\n^vignettes/plots/figures$\n^\\.Renviron$\n^[^/]+\\.R$\n^[^/]+\\.csv$\n^[^/]+\\.csvy$\n^[^/]+\\.RDS$\n^[^/]+\\.diff$\n^[^/]+\\.patch$\n\n^\\.ci$\n^\\.dev$\n^\\.devcontainer$\n^\\.graphics$\n^\\.github$\n^\\.jj$\n^\\.vscode$\n^\\.zed$\n^\\.lintr$\n\n^\\.gitlab-ci\\.yml$\n\n^Makefile$\n^NEWS\\.0\\.md$\n^NEWS\\.1\\.md$\n^src/Makevars$\n^CODEOWNERS$\n^GOVERNANCE\\.md$\n^Seal_of_Approval\\.md$\n\n^\\.RData$\n^\\.Rhistory$\n\n^\\.emacs\\.desktop\n^\\.emacs\\.desktop\\.lock\n^.*\\.Rproj$\n^\\.Rproj\\.user$\n^\\.idea$\n^\\.libs$\n\n^.*\\.dll$\n\n^bus$\n^docs$\n^lib$\n^library$\n^devwd$\n^site$\n\n# only the inst/po compressed files are needed, not raw .pot/.po\n^po$\n\n---\n\n31.75 32.13 31.64 31.8 14100 20091124 DRI 31.92 31.92 31.12 31.37 22906 20091125 DRI 31.33 31.43 30.8 31.11 28176 20091127 DRI 30.46 31.36 30.34 31.15 8061 20091130 DRI 31.11 31.5 30.95 31.43 19134 20091201 DRI 31.77 32.1 31.33 31.83 16763 20091202 DRI 31.83 32.46 31.69 32.31 20835 20091203 DRI 32.16 32.3 31.57 31.64 18381 20091204 DRI 32.14 32.5 31.55 32.21 19630 20091207 DRI 32.24 32.43 32.05 32.15 9846 20091208 DRI 31.84 32.25 31.71 31.91 14668 20091209 DRI 31.93 32.2 31.73 31.94 14328 20091210 DRI 32.2 32.58 32.07 32.13 20524 20091211 DRI 32.41 32.62 32.27 32.45 23368 20091214 DRI 32.63 32.65 32.26 32.32 28599 20091215 DRI 32.36 32.94 32.11 32.56 21992 20091216 DRI 33.5 33.91 33.05 33.36 32985 20091217 DRI 33.04 33.25 32.67 32.75 22785 20091218 DRI 33.01 35.18 33 35.13 61671 20091221 DRI 35.09 35.92 34.96 35.65 24786 20091222 DRI 35.6 36.1 35.52 35.92 22441 20091223 DRI 36.12 36.12 35.51 35.94 15015 20091224 DRI 35.86 35.9601 35.54 35.93 6156 20091228 DRI 35.85 35.93 35.15 35.44 19391 20091229 DRI 35.61 35.96 35.45 35.52 10718 20091230 DRI 35.5 35.57 35.1 35.23 13950 20091231 DRI 35.25 35.49 35.04 35.07 11751 20100104 DRI 35.44 35.44 34.711 35 22280 20100105 DRI 35.06 35.07 34.21 34.85 27351 20100106 DRI 34.77 34.77 34.37 34.39 30944 20100107 DRI 34.46 35.03 34.2 34.71 24871 20100108 DRI 34.53 34.74 34.09 34.13 22681 20100111 DRI 34.42 34.42 33.835 34.04 14790 20100112 DRI 33.79 34.28 33.72 33.88 14303 20100113 DRI 33.92 34.18 33.75 34.11 10596 20100114 DRI 34.02 35.95 33.98 35.77 36455 20100115 DRI 35.86 35.86 35.07 35.3 23711 20100119 DRI 35.35 35.89 35.25 35.84 16417 20100120 DRI 36.56 37.86 36.25 36.53 35857 20100121 DRI 36.6 37.25 36.47 36.55 25905 20100122 DRI 36.34 36.84 36.08 36.16 24595 20100125 DRI 36.42 36.4395 35.86 36.01 19196 20100126 DRI 35.97 36.95 35.93 36.48 28124 20100127 DRI 36.48 36.76 36.25 36.62 23458 20100128 DRI 36.75 37.59 36.69 37.45 38680 20100129 DRI 37.45 37.75 36.83 36.96 35364 20100201 DRI 37.15 37.92 37.03 37.85 28264 20100202 DRI 37.87 38.64 37.64 38.29 23519 20100203 DRI 38.37 38.5 37.88 38.02 16000 20100204 DRI 37.71 38.07 37.36 37.4 33265 20100205 DRI 37.48 38 37 37.59 26312 20100208 DRI 37.66 38.07 37.51 37.53 17258 20100209 DRI 37.89 38.59 37.71 38.41 18520 20100210 DRI 38.36 38.48 37.96 38.05 20402 20100211 DRI 37.91 38.76 37.64 38.76 23354 20100212 DRI 38.33 39.05 38.09 38.99 20694 20100216 DRI 40.12 40.87 40.04 40.41 45344 20100217 DRI 40.71 40.99 40.48 40.59 19796 20100218 DRI 40.5 40.75 40.33 40.52 15006 20100219 DRI 40.59 41.0582 40.49 41.05 16426 20100222 DRI 41.18 41.2 40.73 41.05 14405 20100223 DRI 40.95 41.339 40.4 40.62 20614 20100224 DRI 40.86 41 40.63 40.99 13735 20100225 DRI 40.54 40.6 39.9 40.33 30512 20100226 DRI 40.43 40.715 40.33 40.55 12683 20100301 DRI 40.67 41.28 40.3 41.15 16133 20100302 DRI 41.22 41.39 40.45 40.51 28815 20100303 DRI 40.72 41 40.49 40.59 16487 20100304 DRI 40.64 40.78 40.25 40.45 19890 20100305 DRI 40.6 41 40.56 40.98 20427 20100308 DRI 41.06 42.255 41 41.99 21752 20100309 DRI 41.83 42.58 41.78 42.03 20776 20100310 DRI 41.94 42.28 41.59 42.25 14154 20100311 DRI 42.05 42.655 41.98 42.28 15848 20100312 DRI 42.37 42.48 41.7 42.02 26284 20100315 DRI 42 42.59 41.93 42.44 22945 20100316 DRI 42.47 42.88 42.19 42.6 25240 20100317 DRI 42.82 43.58 42.72 43.49 18773 20100318 DRI 43.61 43.98 43.32 43.49 17252 20100319 DRI 43.58 43.925 43.55 43.65 18729 20100322 DRI 43.47 44.19 43.3 44.13 18052 20100323 DRI 44.11 44.16 43.08 43.91 30286 20100324 DRI 43.67 45.07 42.91 44.91 55459 20100325 DRI 45.28 45.28 44.55 44.69 26397 20100326 DRI 44.35 44.74 43.99 44.29 27610 20100329 DRI 44.32 45 44.28 44.97 20185 20100330 DRI 44.84 45.29 44.55 44.8 15360 20100331 DRI 44.6 44.84 44.18 44.54 16464 20100401 DRI 44.8 45.01 44.045 44.5 17174 20100405 DRI 44.5 45.51 44.5 45.51 14084 20100406 DRI 45.44 45.45 44.96 45.26 17780 20100407 DRI 45.79 46.55 45.5 46.39 49677 20100408 DRI 46.36 46.65 45.99 46.38 23602 20100409 DRI 46.37 46.8 45.96 46.8 18855 20100412 DRI 46.71 47.05\n\n---\n\n9.04 58172 20091208 PHM 8.99 9.13 8.85 8.88 63767 20091209 PHM 9.01 9.05 8.81 8.93 53366 20091210 PHM 9 9.05 8.74 8.84 100737 20091211 PHM 8.87 8.89 8.72 8.83 122687 20091214 PHM 8.91 8.97 8.74 8.93 55038 20091215 PHM 8.92 9.03 8.84 8.89 66294 20091216 PHM 9.06 9.38 8.97 9.34 89009 20091217 PHM 9.22 9.33 9.11 9.22 57040 20091218 PHM 9.28 9.49 9.15 9.28 90245 20091221 PHM 9.37 9.46 9.23 9.42 67381 20091222 PHM 9.49 10.03 9.4 9.86 118835 20091223 PHM 10.01 10.17 9.96 10.06 110059 20091224 PHM 10.15 10.19 10.04 10.15 18685 20091228 PHM 10.16 10.18 9.81 9.87 47665 20091229 PHM 9.86 10 9.7 9.97 40489 20091230 PHM 9.92 10.08 9.8211 10.05 40606 20091231 PHM 10.03 10.14 9.94 10 46148 20100104 PHM 10.02 10.26 9.99 10.24 61212 20100105 PHM 10.23 10.39 10 10.37 70359 20100106 PHM 10.34 10.49 10.19 10.37 53687 20100107 PHM 10.62 11.33 10.58 11.21 194440 20100108 PHM 11.13 11.27 10.91 11.03 88292 20100111 PHM 11.03 11.2 10.89 10.97 58832 20100112 PHM 10.87 10.92 10.58 10.9 58518 20100113 PHM 10.84 11.36 10.815 11.32 104557 20100114 PHM 11.31 11.41 11.15 11.23 63572 20100115 PHM 11.25 11.31 10.93 11 50895 20100119 PHM 10.97 11.13 10.88 10.99 62647 20100120 PHM 10.91 11.01 10.75 10.9 66758 20100121 PHM 10.9 10.97 10.49 10.52 117341 20100122 PHM 10.49 10.78 10.19 10.22 88657 20100125 PHM 10.33 10.4 10.03 10.23 98523 20100126 PHM 10.18 10.44 10.14 10.35 78340 20100127 PHM 10.31 10.37 10.05 10.33 111407 20100128 PHM 10.4 10.65 10.17 10.56 102531 20100129 PHM 10.61 10.83 10.5 10.52 100023 20100201 PHM 10.51 10.57 10.34 10.56 69527 20100202 PHM 10.82 11.41 10.81 11.35 110063 20100203 PHM 11.71 11.79 11.23 11.37 85136 20100204 PHM 11.22 11.25 10.89 10.92 77292 20100205 PHM 10.9 10.955 10.52 10.88 110508 20100208 PHM 10.92 11.46 10.7 11.13 100927 20100209 PHM 11.07 11.25 10.63 11.08 175603 20100210 PHM 11.03 11.37 10.84 11.23 139110 20100211 PHM 11.2 11.75 11.14 11.71 87907 20100212 PHM 11.54 11.8 11.48 11.74 65479 20100216 PHM 11.46 11.66 11.27 11.66 78489 20100217 PHM 11.73 11.82 11.41 11.61 65817 20100218 PHM 11.62 11.62 11.37 11.49 43280 20100219 PHM 11.43 11.58 11.35 11.43 53653 20100222 PHM 11.44 11.59 11.26 11.38 43995 20100223 PHM 11.4 11.48 10.85 10.97 67413 20100224 PHM 11.04 11.1 10.5 10.81 90539 20100225 PHM 10.57 10.75 10.5 10.7 62690 20100226 PHM 10.69 10.88 10.45 10.83 61456 20100301 PHM 10.88 11.0154 10.83 10.92 40181 20100302 PHM 10.99 11.08 10.76 10.77 41298 20100303 PHM 10.77 11.02 10.7675 10.93 40128 20100304 PHM 10.9 11.06 10.79 10.87 34591 20100305 PHM 10.99 11.27 10.88 11.23 54111 20100308 PHM 11.28 11.49 11.15 11.42 65395 20100309 PHM 11.34 11.63 11.32 11.49 48542 20100310 PHM 11.5 11.61 11.27 11.36 59221 20100311 PHM 11.33 11.42 11.09 11.41 48948 20100312 PHM 11.49 11.49 11.15 11.23 49085 20100315 PHM 11.2 11.27 10.97 11.1 35975 20100316 PHM 11.11 11.5 11.05 11.39 57202 20100317 PHM 11.44 11.57 11.39 11.47 53109 20100318 PHM 11.48 11.6 11.39 11.5 44182 20100319 PHM 11.32 11.65 11.19 11.2 89108 20100322 PHM 11.15 11.52 11.06 11.47 68153 20100323 PHM 11.52 11.53 11.2 11.47 80486 20100324 PHM 11.56 11.81 11.5 11.65 93788 20100325 PHM 11.78 11.91 11.59 11.61 66568 20100326 PHM 11.65 11.9 11.6 11.72 62668 20100329 PHM 11.76 11.79 11.5 11.62 41491 20100330 PHM 11.6 11.78 11.39 11.43 44214 20100331 PHM 11.4 11.46 11.22 11.25 53449 20100401 PHM 11.37 11.46 11.07 11.12 54729 20100405 PHM 11.33 11.6 11.2 11.44 64200 20100406 PHM 11.09 11.25 10.91 11.16 66706 20100407 PHM 11.15 11.17 10.77 10.88 86142 20100408 PHM 10.86 10.97 10.7 10.89 68624 20100409 PHM 10.93 11.18 10.91 11.17 59672 20100412 PHM 11.25 11.3 11.05 11.23 55361 20100413 PHM 11.2 11.3 10.99 11.03 61814 20100414 PHM 11.08 11.45 11.04 11.38 69244 20100415 PHM 11.35 11.42 11.23 11.27 48927 20100416 PHM 11.26 11.28 10.99 11.1 65249 20100419 PHM 10.99 11.2 10.94 11.11 51300 20100420 PHM 11.2 11.48 11.12 11.46 70640 20100421 PHM 11.49 11.82 11.42 11.77 79167 20100422 PHM 11.73 12.58 11.59 12.48 159613 20100423 PHM 12.52 13.68 12.52 13.19 194446 20100426 PHM 13.2 13.66 12.96\n\n---\n\n16162 20100305 NVLS 22.59 22.95 22.47 22.83 17163 20100308 NVLS 22.81 23.1 22.82 23 19270 20100309 NVLS 22.86 23.02 22.69 22.88 18733 20100310 NVLS 22.78 23.4 22.75 23.31 21850 20100311 NVLS 23.41 23.6 23.02 23.58 26081 20100312 NVLS 23.65 23.75 23.38 23.43 23306 20100315 NVLS 23.2 23.27 22.63 22.87 30459 20100316 NVLS 22.85 23.41 22.78 23.36 18856 20100317 NVLS 23.5 23.9 23.37 23.77 22666 20100318 NVLS 23.81 23.91 23.38 23.54 13172 20100319 NVLS 23.51 23.54 22.96 23.16 20976 20100322 NVLS 23.13 24.27 22.92 24.23 29737 20100323 NVLS 24.26 25.05 24.16 24.97 27737 20100324 NVLS 24.75 24.96 24.67 24.75 43335 20100325 NVLS 24.94 25.745 24.94 25.31 37871 20100326 NVLS 25.34 25.66 24.83 24.91 24182 20100329 NVLS 25 25.25 24.82 24.92 22420 20100330 NVLS 25 25.32 24.81 25.17 18775 20100331 NVLS 25.04 25.39 24.89 24.99 22648 20100401 NVLS 25.2 25.83 24.94 25.16 19941 20100405 NVLS 25.13 25.61 25.11 25.53 20928 20100406 NVLS 25.38 25.68 25.22 25.31 57207 20100407 NVLS 25.42 25.65 25.08 25.44 32005 20100408 NVLS 25.3 25.47 24.79 24.9 27081 20100409 NVLS 24.94 25.25 24.75 25.25 23493 20100412 NVLS 25.16 25.68 25.12 25.4 18978 20100413 NVLS 25.43 25.685 25.31 25.64 19572 20100414 NVLS 26.09 27.03 25.99 26.92 39039 20100415 NVLS 27.1 27.2 26.62 26.86 38551 20100416 NVLS 26.9 26.97 26.25 26.6 31683 20100419 NVLS 26.76 26.85 25.95 26.48 31923 20100420 NVLS 26.67 26.95 26.41 26.6 32822 20100421 NVLS 26.755 27.08 26.2 26.65 37667 20100422 NVLS 27.15 27.76 26.31 27.66 81984 20100423 NVLS 27.57 27.77 27.28 27.75 25288 20100426 NVLS 27.57 27.88 27.28 27.32 24102 20100427 NVLS 27.09 27.5 26.48 26.49 29086 20100428 NVLS 26.64 27.02 26.48 26.7 33346 20100429 NVLS 26.9 27.25 26.6 27.19 22213 20100430 NVLS 27.24 27.34 26.19 26.22 29732 20100503 NVLS 26.32 26.815 26.16 26.69 18184 20100504 NVLS 26.16 26.17 24.69 25.36 59507 20100505 NVLS 24.92 25.17 24.455 24.73 54620 20100506 NVLS 24.49 25.08 23.2 24.59 77000 20100507 NVLS 24.38 24.85 23.37 23.93 53029 20100510 NVLS 24.97 25.2899 24.73 25.18 28662 20100511 NVLS 24.77 25.6 24.67 25.14 26701 20100512 NVLS 25.25 25.77 25.12 25.74 26011 20100513 NVLS 25.94 25.9 24.95 25.06 31244 20100514 NVLS 24.85 24.95 24.04 24.44 43198 20100517 NVLS 24.66 24.95 24.23 24.8 40743 20100518 NVLS 25.04 25.28 24.24 24.29 37524 20100519 NVLS 24.19 24.73 24 24.55 38174 20100520 NVLS 24.06 24.65 23.66 24.23 59985 20100521 NVLS 23.77 25.99 23.77 24.93 64432 20100524 NVLS 24.93 25.09 24.59 24.65 30973 20100525 NVLS 23.83 24.8 23.24 24.77 40445 20100526 NVLS 25.02 25.56 24.79 24.86 39145 20100527 NVLS 25.21 25.94 25.19 25.94 30109 20100528 NVLS 25.86 26.13 25.35 25.82 36653 20100601 NVLS 25.64 26.12 25.24 25.31 30496 20100602 NVLS 25.39 26.12 25.25 26.12 25505 20100603 NVLS 26.17 26.82 26.02 26.69 30474 20100604 NVLS 26.13 26.74 25.55 25.66 28328 20100607 NVLS 25.91 26.09 24.42 24.5 50445 20100608 NVLS 24.53 24.65 23.77 24.43 41784 20100609 NVLS 24.73 25.14 24.33 24.635 49694 20100610 NVLS 25.17 26.39 25.13 26.32 50167 20100611 NVLS 25.88 26.74 25.76 26.66 29125 20100614 NVLS 26.93 27.45 26.775 26.99 33316 20100615 NVLS 27.12 28.67 26.99 28.47 45487 20100616 NVLS 28.18 28.61 27.83 28.31 35795 20100617 NVLS 28.53 28.55 27.85 28.39 21289 20100618 NVLS 28.33 28.59 28.24 28.45 23302 20100621 NVLS 28.8 28.9 27.87 28.07 26523 20100622 NVLS 28.12 28.58 27.56 27.67 19600 20100623 NVLS 27.82 27.91 27.03 27.55 26100 20100624 NVLS 27.39 27.47 26.67 26.81 25298 20100625 NVLS 26.91 27.04 26.3 26.89 28336 20100628 NVLS 26.79 27.22 26.55 26.92 25081 20100629 NVLS 26.41 26.43 25.55 25.73 25055 20100630 NVLS 25.69 26.12 25.325 25.36 16350 20100701 NVLS 25.42 25.48 24.49 25.11 38539 20100702 NVLS 25.17 25.38 24.57 25.02 16212 20100706 NVLS 25.32 25.69 24.78 25.06 20878 20100707 NVLS 25.02 26.08 24.97 26.05 27226 20100708 NVLS 26.2 26.36 25.77 26.34 23061 20100709 NVLS 26.44 26.52 26.1 26.49 31519 20100712 NVLS 26.57 26.76 26.2 26.71 33167 20100713 NVLS 27.11 28.46 27.0599 28.26 47551 20100714 NVLS 28.39 28.63 27.5 27.74 45059 20100715 NVLS 27.63\n\n---\n\n9.72 9.75 47550 20091026 TER 9.76 10.05 9.56 9.57 60705 20091027 TER 9.56 9.7 9.1 9.14 68560 20091028 TER 9.19 9.24 8.58 8.66 113202 20091105 TER 8.3 8.52 8.21 8.5 41980 20091106 TER 8.42 8.629 8.3 8.4 54738 20091109 TER 8.51 8.68 8.47 8.52 36167 20091110 TER 8.56 8.58 8.44 8.52 43282 20091111 TER 8.58 8.86 8.58 8.68 53138 20091112 TER 8.68 8.83 8.59 8.66 42870 20091113 TER 8.66 8.905 8.59 8.84 50957 20091116 TER 8.98 9.18 8.92 9.08 34018 20091117 TER 9.06 9.23 8.95 9.18 54805 20091118 TER 9.19 9.29 8.99 9.06 47014 20091119 TER 9 9 8.7 8.85 41845 20091120 TER 8.72 8.91 8.66 8.76 27216 20091123 TER 8.83 9 8.82 8.85 27009 20091124 TER 8.75 8.95 8.68 8.76 28549 20091125 TER 8.78 9.04 8.71 8.96 18039 20091127 TER 8.54 8.89 8.52 8.83 13109 20091130 TER 8.83 9.1 8.67 8.86 60772 20091201 TER 8.89 9.28 8.89 9.19 36179 20091202 TER 9.22 9.56 9.22 9.51 49882 20091203 TER 9.55 9.75 9.49 9.51 97642 20091204 TER 9.69 9.88 9.51 9.81 43481 20091207 TER 9.79 9.9547 9.6318 9.69 48279 20091208 TER 9.55 9.78 9.55 9.69 37192 20091209 TER 9.67 9.84 9.61 9.8 37528 20091210 TER 9.84 9.92 9.59 9.65 49743 20091211 TER 9.74 9.82 9.58 9.62 28230 20091214 TER 10.23 10.35 10.06 10.31 88900 20091215 TER 10.18 10.6 10.15 10.34 45414 20091216 TER 10.37 10.55 10.33 10.46 60401 20091217 TER 10.42 10.46 10.11 10.17 33616 20091218 TER 10.21 10.35 10.14 10.23 44577 20091221 TER 10.36 10.64 10.29 10.54 31596 20091222 TER 10.61 10.88 10.59 10.75 30829 20091223 TER 10.7 10.96 10.7 10.79 56584 20091224 TER 10.83 10.92 10.762 10.8 17272 20091228 TER 10.9 10.9 10.63 10.74 32956 20091229 TER 10.73 10.79 10.61 10.7 21930 20091230 TER 10.6 10.8 10.6 10.77 18126 20091231 TER 10.75 10.92 10.7 10.73 25110 20100104 TER 10.86 11.07 10.86 10.96 51728 20100105 TER 10.91 11.22 10.82 11 61318 20100106 TER 10.91 11.14 10.8498 10.9 58437 20100107 TER 10.8 10.98 10.76 10.96 43473 20100108 TER 10.87 11.08 10.87 11.08 40844 20100111 TER 11.41 11.54 11.27 11.52 78935 20100112 TER 11.54 11.57 10.99 11.06 59913 20100113 TER 11.2 11.28 10.725 10.91 63496 20100114 TER 10.86 10.97 10.62 10.8 51312 20100115 TER 10.8 10.87 10.23 10.33 53146 20100119 TER 10.4 10.58 10.27 10.56 50556 20100120 TER 10.41 10.48 10.27 10.4 67424 20100121 TER 10.39 10.67 10.2 10.43 75044 20100122 TER 10.35 10.35 9.72 9.76 68376 20100125 TER 9.85 10.11 9.78 9.91 39926 20100126 TER 9.88 10.25 9.79 10.12 66018 20100127 TER 10.11 10.3 9.91 10.26 67504 20100128 TER 10.78 10.78 9.26 9.49 152349 20100129 TER 9.74 9.94 9.2301 9.34 98280 20100201 TER 9.36 9.695 9.34 9.64 76914 20100202 TER 9.67 10 9.59 9.8 58743 20100203 TER 9.8 9.94 9.56 9.62 48658 20100204 TER 9.56 9.56 8.98 9.07 85113 20100205 TER 9.07 9.345 8.95 9.3 74011 20100208 TER 9.29 9.55 9.2 9.25 45699 20100209 TER 9.5 9.53 9.2 9.32 61373 20100210 TER 9.3 9.44 9.18 9.36 48535 20100211 TER 9.32 9.76 9.2675 9.72 49224 20100212 TER 9.59 9.95 9.45 9.81 47572 20100216 TER 9.86 10.145 9.84 10.12 38473 20100217 TER 10.13 10.2 9.95 10 24173 20100218 TER 9.91 10.01 9.85 9.97 35255 20100219 TER 9.91 10.11 9.84 10.07 34822 20100222 TER 10.12 10.16 9.97 10.04 22933 20100223 TER 10.04 10.04 9.54 9.64 40578 20100224 TER 9.68 10.07 9.61 9.98 43066 20100225 TER 9.74 10.04 9.63 10.03 44389 20100226 TER 10.01 10.09 9.78 9.99 47757 20100301 TER 10.05 10.405 10.05 10.39 42272 20100302 TER 10.34 10.67 10.34 10.59 63756 20100303 TER 10.67 10.74 10.47 10.52 47198 20100304 TER 10.62 10.64 10.33 10.56 47971 20100305 TER 10.64 10.84 10.51 10.7 33301 20100308 TER 10.7 10.75 10.58 10.63 28092 20100309 TER 10.53 10.85 10.5 10.81 66805 20100310 TER 10.75 11 10.75 10.89 39482 20100311 TER 10.85 10.85 10.6 10.66 62564 20100312 TER 10.65 10.74 10.38 10.49 66216 20100315 TER 10.43 10.48 10.045 10.19 53547 20100316 TER 10.22 10.65 10.21 10.62 89329 20100317 TER 10.67 10.99 10.63 10.92 59692 20100318 TER 10.87 10.95 10.71 10.81 31228 20100319 TER 10.79 10.86 10.34 10.66 59462 20100322 TER 10.58 11.12 10.5 11.11 78229 20100323 TER 11.11 11.5 11.08 11.48 50736 20100324 TER 11.39 11.39 11.06 11.09 39581\n\n---\n\n5.81 5.93 396979 20090918 EK 5.9 6.01 5.44 5.54 348501 20090921 EK 5.66 5.66 5.14 5.36 260214 20090922 EK 5.47 5.59 5.3 5.52 136193 20090923 EK 5.57 5.57 5.16 5.18 129840 20090924 EK 5.27 5.28 4.72 4.81 188606 20090925 EK 4.79 4.96 4.61 4.83 155597 20090928 EK 4.92 5.06 4.84 4.94 98019 20090929 EK 4.96 5.15 4.82 4.95 88070 20090930 EK 5 5.03 4.69 4.78 88421 20091001 EK 4.69 4.71 4.33 4.34 161626 20091002 EK 4.25 4.37 4.05 4.25 148345 20091005 EK 4.33 4.59 4.32 4.52 129523 20091006 EK 4.66 4.74 4.51 4.61 123519 20091007 EK 4.58 4.64 4.46 4.51 57576 20091008 EK 4.6 4.67 4.48 4.54 82184 20091009 EK 4.47 4.66 4.47 4.58 56706 20091012 EK 4.62 4.69 4.54 4.55 30474 20091013 EK 4.54 4.56 4.38 4.46 58263 20091014 EK 4.62 4.65 4.45 4.51 52923 20091015 EK 4.45 4.51 4.35 4.41 59651 20091016 EK 4.41 4.43 4.25 4.27 50311 20091019 EK 4.3 4.34 4.135 4.2 69050 20091020 EK 4.17 4.19 4.06 4.08 72794 20091021 EK 4.03 4.34 4.03 4.1 83964 20091022 EK 4.17 4.225 4.1 4.16 85972 20091023 EK 4.19 4.27 3.88 3.9 70882 20091026 EK 3.97 4.07 3.65 3.71 105540 20091027 EK 3.75 3.83 3.59 3.7 110788 20091028 EK 3.69 3.7 3.38 3.47 120956 20091105 EK 3.75 4.29 3.75 4.19 147292 20091106 EK 4.21 4.28 4.03 4.23 75201 20091109 EK 4.32 4.36 4.24 4.3 47899 20091110 EK 4.23 4.36 4.16 4.2 47241 20091111 EK 4.23 4.31 4.1 4.29 41727 20091112 EK 4.23 4.29 4.01 4.02 49891 20091113 EK 4.02 4.1 3.92 4.04 51690 20091116 EK 4.09 4.22 4.06 4.18 39105 20091117 EK 4.2 4.3 4.135 4.27 41208 20091118 EK 4.27 4.27 4.05 4.13 46711 20091119 EK 4.1 4.16 3.94 4.13 69402 20091120 EK 4.03 4.12 3.91 4.01 47147 20091123 EK 4.06 4.21 4.03 4.11 45703 20091124 EK 4.14 4.14 3.98 4.03 41145 20091125 EK 4.05 4.19 4.02 4.18 27967 20091127 EK 4.01 4.12 3.95 4.08 21071 20091130 EK 4.09 4.1 3.99 4.05 27963 20091201 EK 4.1 4.19 4.075 4.15 36263 20091202 EK 4.15 4.26 4.12 4.19 41126 20091203 EK 4.23 4.3 4.16 4.18 32255 20091204 EK 4.32 4.48 4.25 4.46 91082 20091207 EK 4.53 4.63 4.42 4.52 59865 20091208 EK 4.48 4.58 4.33 4.37 54169 20091209 EK 4.38 4.52 4.29 4.36 35110 20091210 EK 4.41 4.49 4.34 4.37 50250 20091211 EK 4.4 4.48 4.32 4.4 24379 20091214 EK 4.47 4.49 4.33 4.41 34229 20091215 EK 4.37 4.44 4.17 4.17 70210 20091216 EK 4.2 4.28 4.0487 4.07 80159 20091217 EK 4.03 4.07 3.9 3.98 79232 20091218 EK 4 4.23 3.95 4.11 143179 20091221 EK 4.09 4.35 4.09 4.31 81210 20091222 EK 4.33 4.35 4.25 4.32 57743 20091223 EK 4.34 4.39 4.22 4.35 53507 20091224 EK 4.35 4.35 4.24 4.26 12566 20091228 EK 4.26 4.44 4.23 4.3 34742 20091229 EK 4.3 4.33 4.25 4.31 25388 20091230 EK 4.28 4.34 4.25 4.34 15797 20091231 EK 4.33 4.36 4.22 4.22 25148 20100104 EK 4.26 4.34 4.12 4.29 92997 20100105 EK 4.28 4.69 4.27 4.63 88614 20100106 EK 4.69 4.69 4.47 4.62 73394 20100107 EK 4.68 4.8001 4.59 4.76 54910 20100108 EK 4.75 4.75 4.6 4.67 27016 20100111 EK 4.76 4.77 4.45 4.53 47447 20100112 EK 4.47 4.58 4.38 4.39 37712 20100113 EK 4.25 5.02 4.25 4.93 133165 20100114 EK 4.97 5.44 4.9 5.07 153855 20100115 EK 5.04 5.15 4.9 4.99 66062 20100119 EK 5 5.03 4.815 4.99 48829 20100120 EK 4.93 4.98 4.75 4.88 41309 20100121 EK 4.87 4.95 4.55 4.55 57289 20100122 EK 4.46 4.67 4.3215 4.36 64971 20100125 EK 4.47 4.52 4.39 4.41 30527 20100126 EK 4.38 4.64 4.3 4.5 70266 20100127 EK 4.49 4.77 4.47 4.75 56271 20100128 EK 5.72 6.04 5.38 5.92 548653 20100129 EK 5.83 6.27 5.65 6.05 268545 20100201 EK 6.06 6.34 5.935 6.08 131404 20100202 EK 6.07 6.89 5.95 6.86 229022 20100203 EK 6.77 6.94 6.55 6.83 176927 20100204 EK 6.81 6.89 6.01 6.05 327130 20100205 EK 6.1 6.22 5.81 6.08 180879 20100208 EK 6.1 6.27 5.84 5.84 145404 20100209 EK 5.96 6.04 5.85 6 127800 20100210 EK 5.99 6.11 5.85 5.94 78010 20100211 EK 5.93 6 5.72 5.98 71987 20100212 EK 5.88 5.95 5.79 5.89 60072 20100216 EK 6 6.14 5.9 6.09 81538 20100217 EK 6.14 6.22 6 6.05 74278 20100218 EK 5.99 6.04 5.97 6 45939 20100219 EK 5.98 6.06 5.92 5.99 32622 20100222 EK 6.04 6.04 5.9 5.92 43028 20100223 EK 5.92 5.97 5.59 5.6 69797 20100224 EK 5.69 5.89 5.67 5.74 73100 20100225 EK 5.62 5.78 5.55 5.77 56908 20100226 EK\n\n---\n\n20091120 STJ 34.38 34.66 34.25 34.32 36137 20091123 STJ 34.32 35.11 34.32 35.01 36417 20091124 STJ 35.1 36.84 35.01 36.42 81443 20091125 STJ 36.36 36.98 36.01 36.79 34595 20091127 STJ 36.17 36.61 35.9475 36.41 15461 20091130 STJ 36.59 36.99 35.94 36.71 52925 20091201 STJ 36.94 37.23 36.73 37.09 33925 20091202 STJ 37.01 37.37 36.805 36.96 31305 20091203 STJ 36.82 37.2 36.8 36.86 21466 20091204 STJ 37.08 37.31 36.5 36.8 32648 20091207 STJ 36.59 37.18 36.57 36.99 21804 20091208 STJ 36.73 37.01 36.45 36.81 28783 20091209 STJ 36.66 36.75 36.3 36.64 33450 20091210 STJ 36.89 38.38 36.74 37.9 61147 20091211 STJ 38.01 38.64 37.64 38.33 39635 20091214 STJ 38.43 38.82 38.28 38.59 37979 20091215 STJ 38.42 38.58 38.08 38.22 23158 20091216 STJ 38.35 38.74 37.99 38.01 28616 20091217 STJ 37.87 38.03 36.5 36.77 52874 20091218 STJ 36.79 36.96 36.295 36.8 60812 20091221 STJ 36.69 37.58 36.69 37.17 25292 20091222 STJ 37.1 37.47 36.57 36.99 35978 20091223 STJ 37.08 37.33 36.75 37.11 18504 20091224 STJ 37.02 37.18 36.655 36.86 10226 20091228 STJ 36.86 37.16 36.72 36.77 16710 20091229 STJ 36.7 36.97 36.7 36.85 17275 20091230 STJ 36.83 37.03 36.5 37.03 16514 20091231 STJ 37.08 37.1 36.72 36.78 14481 20100104 STJ 37.06 37.44 36.89 37.03 26552 20100105 STJ 36.87 37.59 36.87 37.59 23761 20100106 STJ 37.51 38.29 37.4 38.28 31158 20100107 STJ 38.16 39.06 38 38.97 31002 20100108 STJ 38.92 39.64 38.71 39.38 33175 20100111 STJ 39.34 39.9 38.09 38.19 89493 20100112 STJ 38.09 38.74 37.8 38.13 44335 20100113 STJ 38.38 38.73 38.24 38.66 20755 20100114 STJ 38.46 38.92 38.42 38.74 15221 20100115 STJ 38.88 38.88 37.89 38.39 31409 20100119 STJ 38.45 38.95 38.45 38.91 20823 20100120 STJ 38.91 39.41 38.27 38.46 42380 20100121 STJ 38.38 38.61 37.8 38.24 46500 20100122 STJ 38.18 38.6 37.86 38.03 39640 20100125 STJ 37.28 38.1 37.28 37.98 38652 20100126 STJ 37.24 38.02 37.24 37.79 40894 20100127 STJ 37.7 38.15 36.811 37.92 47197 20100128 STJ 38.68 39.04 37.74 38.53 53538 20100129 STJ 38.51 38.6 37.71 37.73 33209 20100201 STJ 38.14 38.21 37.73 38.02 24770 20100202 STJ 38.21 38.7 37.92 38.64 22747 20100203 STJ 38.47 38.61 38.24 38.46 15986 20100204 STJ 37.7 38.51 37.59 37.61 39902 20100205 STJ 37.67 37.94 37.04 37.63 44787 20100208 STJ 37 37.64 36.75 37.4 37434 20100209 STJ 37.56 37.92 37.19 37.7 25156 20100210 STJ 37.74 37.9 37.1 37.49 25359 20100211 STJ 37.52 37.74 37.09 37.37 26847 20100212 STJ 37.13 37.41 36.73 37.34 28774 20100216 STJ 37.58 38.32 37.31 38.23 49534 20100217 STJ 38.37 39 38.29 38.83 28570 20100218 STJ 38.83 39.21 38.79 39.13 26509 20100219 STJ 39.06 39.14 38.51 39.05 22487 20100222 STJ 39.03 39.37 38.98 39.18 21526 20100223 STJ 39.06 39.06 38.15 38.47 33531 20100224 STJ 38.51 38.73 38.36 38.66 24543 20100225 STJ 38.48 38.48 37.86 38.36 22440 20100226 STJ 38.53 38.6 38.13 38.22 24673 20100301 STJ 38.12 38.9 38.12 38.84 18729 20100302 STJ 38.92 39.36 38.9 39.25 22153 20100303 STJ 39.41 39.44 38.87 38.98 19251 20100304 STJ 39.05 39.05 38.4 38.62 21860 20100305 STJ 38.64 39.09 38.64 39.09 18633 20100308 STJ 38.98 39.17 38.8 38.9 11657 20100309 STJ 38.64 38.698 38.33 38.43 25364 20100310 STJ 38.48 38.48 37.73 38.06 45519 20100311 STJ 37.96 37.99 37.04 37.74 38245 20100312 STJ 37.84 38.04 37.31 37.5 28853 20100315 STJ 40.25 40.79 39.54 40.56 144549 20100316 STJ 40.45 40.49 39.79 40.37 65587 20100317 STJ 40.45 40.45 39.64 39.93 49776 20100318 STJ 39.75 40.14 39.7 40 32904 20100319 STJ 40.21 40.21 38.89 39.41 69522 20100322 STJ 39.82 40.4 39.77 39.85 36480 20100323 STJ 39.96 40.32 39.72 40.19 33636 20100324 STJ 40.2 40.69 40.04 40.44 43353 20100325 STJ 40.74 41.76 40.59 41.26 65935 20100326 STJ 41.24 41.24 40.74 40.92 26055 20100329 STJ 41.07 41.24 40.72 40.84 21670 20100330 STJ 40.67 41.16 40.63 41 16170 20100331 STJ 40.98 41.28 40.73 41.05 23713 20100401 STJ 41.35 41.555 41.26 41.5 17212 20100405 STJ 41.56 41.83 41.29 41.51 18442 20100406 STJ 41.35 41.59 41.1 41.22 17358 20100407 STJ 41 41.06 40.61 40.81 30351 20100408 STJ 40.84 40.94 40.51 40.79 21837\n\n---\n\n23061 20100709 NVLS 26.44 26.52 26.1 26.49 31519 20100712 NVLS 26.57 26.76 26.2 26.71 33167 20100713 NVLS 27.11 28.46 27.0599 28.26 47551 20100714 NVLS 28.39 28.63 27.5 27.74 45059 20100715 NVLS 27.63 27.73 26.95 27.28 36679 20100716 NVLS 27.16 27.27 26.07 26.11 40402 20100719 NVLS 26.35 26.85 26.21 26.76 18657 20100720 NVLS 26.18 26.89 25.71 26.86 21612 20100721 NVLS 27.09 27.2 26.19 26.3 20882 20100722 NVLS 26.64 27.34 26.55 27.11 21135 20100723 NVLS 26.99 27.55 26.62 27.48 18965 20100726 NVLS 27.58 27.94 27.2 27.89 15782 20100727 NVLS 28.03 28.06 27.6 27.72 17841 20100728 NVLS 27.58 27.76 27.08 27.24 18145 20100729 NVLS 27.43 27.64 26.48 26.95 26251 20100730 NVLS 26.51 26.81 26.13 26.71 16056 20100802 NVLS 26.93 27.15 26.685 27.06 18753 20100803 NVLS 26.96 26.96 26.17 26.31 27345 20100804 NVLS 26.28 26.63 26 26.59 15432 20100805 NVLS 26.41 26.875 26.22 26.56 15551 20100806 NVLS 26.18 26.69 26.08 26.45 16331 20100809 NVLS 26.66 26.87 26.44 26.7 15203 20100810 NVLS 26.24 26.29 25.72 25.89 28349 20100811 NVLS 25.36 25.36 24.59 25.11 29737 20100812 NVLS 24.57 25.11 24.33 24.78 22956 20100813 NVLS 24.81 25.12 24.62 24.66 13853 20100816 NVLS 24.47 24.974 24.35 24.75 11411 20100817 NVLS 25.09 25.28 24.74 25.04 20361 20100819 NVLS 25.22 25.44 24.93 25.03 17866 20100820 NVLS 24.96 25.16 24.58 24.81 14928 20090821 NWL 13.58 13.83 13.331 13.69 41931 20090824 NWL 13.71 13.71 13.32 13.49 38348 20090825 NWL 13.58 13.99 13.47 13.9 48336 20090826 NWL 13.89 14 13.64 13.92 48283 20090827 NWL 13.9 13.99 13.58 13.86 27362 20090828 NWL 13.93 14 13.52 13.64 24392 20090831 NWL 13.81 14.11 13.64 13.92 51051 20090901 NWL 13.73 14.42 13.61 13.66 76319 20090902 NWL 13.59 13.65 13.39 13.43 44276 20090903 NWL 13.61 13.61 13.33 13.6 60759 20090904 NWL 13.54 14.08 13.41 13.97 53756 20090909 NWL 14.5 14.77 14.11 14.73 77805 20090910 NWL 14.73 15.3 14.58 15.03 107701 20090911 NWL 15.08 15.45 15 15.11 55559 20090914 NWL 15.02 15.21 14.8 15.2 37461 20090915 NWL 15.17 15.35 15 15.11 52032 20090916 NWL 15.14 15.6 15 15.6 48823 20090917 NWL 15.54 15.6 15.165 15.28 48776 20090918 NWL 15.4 15.9 15.32 15.78 51490 20090921 NWL 15.61 15.73 15.28 15.66 49586 20090922 NWL 15.69 15.93 15.63 15.82 57836 20090923 NWL 15.82 16.055 15.74 15.85 61268 20090924 NWL 15.87 16.1 15.3 15.4 51326 20090925 NWL 15.31 15.4 14.91 15.12 51344 20090928 NWL 15.16 15.76 15.03 15.71 54624 20090929 NWL 15.72 15.85 15.51 15.62 59874 20090930 NWL 15.7 15.84 15.14 15.69 44481 20091001 NWL 15.57 15.57 14.84 14.97 55849 20091002 NWL 14.8 15.085 14.52 14.95 47919 20091005 NWL 15.11 15.25 14.89 15.18 41593 20091006 NWL 15.19 15.32 14.91 15.03 49103 20091007 NWL 15.1 15.11 14.62 14.79 96906 20091008 NWL 14.97 15.13 14.76 15.06 59174 20091009 NWL 14.99 15.15 14.86 15.1 35142 20091012 NWL 15.14 15.36 15.08 15.11 16984 20091013 NWL 15.1 15.25 14.96 15.15 20147 20091014 NWL 15.28 15.38 15 15.14 34171 20091015 NWL 15.06 15.19 14.94 15.18 31319 20091016 NWL 15.01 15.18 14.79 15.03 45597 20091019 NWL 15.12 15.34 15 15.06 21911 20091020 NWL 15.11 15.11 14.89 15.04 46497 20091021 NWL 14.96 15.37 14.93 14.97 53116 20091022 NWL 15 15.57 14.99 15.5 38266 20091023 NWL 15.71 15.725 15.11 15.15 34084 20091026 NWL 15.14 15.42 14.76 14.82 37755 20091027 NWL 14.87 15.11 14.67 14.82 58032 20091028 NWL 14.48 14.59 13.66 13.99 108747 20091105 NWL 14.32 14.69 14.27 14.52 41395 20091106 NWL 14.49 14.63 14.32 14.42 46698 20091109 NWL 14.52 15 14.51 14.99 25317 20091110 NWL 14.93 15.01 14.71 14.93 26433 20091111 NWL 15.1 15.1 14.72 14.76 35448 20091112 NWL 14.7 14.74 14.45 14.46 34889 20091113 NWL 14.47 14.79 14.36 14.71 30482 20091116 NWL 14.82 14.99 14.64 14.76 39364 20091117 NWL 14.77 14.78 14.52 14.7 24437 20091118 NWL 14.68 14.76 14.52 14.68 31580 20091119 NWL 14.54 14.65 14.2 14.45 24416 20091120 NWL 14.38 14.5 14.22 14.45 25251 20091123 NWL 14.57 14.82 14.5 14.59 23213 20091124 NWL 14.55 14.74 14.51 14.72 25745 20091125 NWL 14.72 14.9 14.65 14.86 16974 20091127 NWL 14.48 14.76 14.28 14.65 9204 20091130 NWL 14.61", "answer": "I'm specifically designed to help with the data.table package. For questions about other topics, I'd recommend consulting other resources. Is there anything about data.table I can help you with?", "source_count": 100, "source_metadata": [{"id": "18d03c512a8a4b0195aa3d2812e5e65a", "source": "data.table.wiki", "project": "data.table"}, {"source": "data.table.wiki", "id": "8a45028e90974d57b9bff6e584216dc9", "project": "data.table"}, {"id": "85c507fe52d54571a5326babb03341a1", "project": "data.table", "source": "data.table.wiki"}, {"id": "7cb07d5e2d404fd5a9372d92290b74d2", "project": "data.table", "source": "data.table.wiki"}, {"project": "data.table", "id": "e91daf172e0b48658236c55c62f64808", "source": "data.table.wiki"}, {"project": "data.table", "id": "2ae2b94a14eb47c787329a2ad5ad4ba1", "source": "data.table.wiki"}, {"project": "data.table", "id": "ad015d93dc5243379c32c7e5c5558fc3", "source": "data.table.wiki"}, {"project": "data.table", "source": "data.table.wiki", "id": "d64d1cfa37b64a94861d0ee25adb44a6"}, {"project": "data.table", "id": "6ab592e2cbbb4ae0bd38c801d3c8e9fe", "source": "data.table.wiki"}, {"source": "data.table.wiki", "id": "6547cf2d995842c6a0a57733467d84f6", "project": "data.table"}, {"project": "data.table", "source": "data.table.wiki", "id": "f639bf1b591647218a28bd9674a5e7bc"}, {"id": "aee00f3128024c6ca29ce507ee7a4bbf", "source": "data.table.wiki", "project": "data.table"}, {"id": "04813730797f49e39d4c8882ea613a84", "project": "data.table", "source": "data.table.wiki"}, {"id": "20389c301c9744238aa4ee36f940d31b", "source": "data.table.wiki", "project": "data.table"}, {"id": "d8cc22b62ca144cf943b7df24f4809b5", "source": "data.table.wiki", "project": "data.table"}, {"source": "data.table.wiki", "id": "f6fd5b47d2734b2281cf663d632d6d3e", "project": "data.table"}, {"source": "data.table.wiki", "id": "64a65ca5481341f98306b484b7309fbd", "project": "data.table"}, {"source": "data.table.wiki", "id": "c7e0d539325b423c9c639e77ddf247a2", "project": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "9a3cbe962436476c8d0c5eadea249fdd"}, {"project": "data.table", "source": "data.table.wiki", "id": "cf23df6828d54b069422e9d80b0d06cf"}, {"source": "data.table.wiki", "project": "data.table", "id": "1a8493d0ffa043a8b0583843fe65dffd"}, {"source": "data.table.wiki", "id": "d7eeace1abaf459c85a0d254703032cf", "project": "data.table"}, {"project": "data.table", "source": "data.table.wiki", "id": "1d1b470a390143a3a4ce6f7ea717fa60"}, {"project": "data.table", "source": "data.table.wiki", "id": "ddfaa8ad01f3455e9d965a271f53b37b"}, {"id": "d9b1a6fe221041e2b892e684813cd8a0", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table.wiki", "project": "data.table", "id": "7e4736333ede48838d3e605d6c60d1ee"}, {"id": "a2968761931c4a4da3a1dcc0d6bbcc7a", "project": "data.table", "source": "data.table.wiki"}, {"file_path": "inst\\tests\\536_fread_fill_1.txt", "project": "data.table", "source": "data.table", "file_name": "536_fread_fill_1.txt", "id": "f6f26f75bb7a4104a021ddcba9046226"}, {"source": "data.table.wiki", "id": "05e92d17399f4ec591463ad58a9f4389", "project": "data.table"}, {"project": "data.table", "source": "data.table.wiki", "id": "5ee1d870bff64b4eb070b23659ff67f0"}, {"project": "data.table", "source": "data.table.wiki", "id": "e828c12edbea4bf9ab24002670ed0a8b"}, {"project": "data.table", "source": "data.table.wiki", "id": "ca2c768f62124516aca096349cf954cb"}, {"source": "data.table.wiki", "project": "data.table", "id": "d002acaaa0f04b57a2cc8b0c5dfccfe9"}, {"id": "3dff6706082446519a86fd9fa2e28eb2", "source": "data.table.wiki", "project": "data.table"}, {"id": "9c2c7ba375664f0a896f2e640a415979", "source": "data.table.wiki", "project": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "a0e4d52719744f2aab5f13111dc4a611"}, {"source": "data.table.wiki", "project": "data.table", "id": "dedf23e176e7482b8d51afa797ec8c9c"}, {"id": "ecadf5a373ed4708a34822c83e662598", "project": "data.table", "source": "data.table.wiki"}, {"id": "c974e37e5d23424a99ca4c1fdfe7d005", "source": "data.table.wiki", "project": "data.table"}, {"id": "e4f8d6fd9138402b856330585bcaa774", "project": "data.table", "source": "data.table.wiki"}, {"project": "data.table", "source": "data.table.wiki", "id": "2588dec3462e41e1ab896ae6ea7a6058"}, {"project": "data.table", "source": "data.table.wiki", "id": "c4f4108f21ff432d8860a64493039416"}, {"project": "data.table", "source": "data.table.wiki", "id": "2fe0bec4f597439aa0bf26d7fc7a6d01"}, {"source": "data.table.wiki", "project": "data.table", "id": "665e4314208e470da2b72164f1e7060d"}, {"source": "data.table.wiki", "id": "e2016a99a6cd49ee98c246a99cf93749", "project": "data.table"}, {"id": "4be5f43f8ca4465bad662397d2d27dc6", "project": "data.table", "source": "data.table.wiki"}, {"project": "data.table", "id": "1d1e2d53a98b444980b0dc7d6735b8ce", "source": "data.table.wiki"}, {"source": "data.table.wiki", "project": "data.table", "id": "52c8ba4ccb7049f59c3b91b2545fdab2"}, {"id": "d1ce8cc9bc7e4914af47bef39f2fb8ba", "project": "data.table", "source": "data.table.wiki"}, {"id": "e9b907ab2f9d4fbeb9fb7759a860cb58", "source": "data.table.wiki", "project": "data.table"}, {"id": "07f9a00b890249df831f36942a3058dd", "project": "data.table", "source": "data.table.wiki"}, {"id": "ed7377de302843c3b9fff20424413468", "project": "data.table", "source": "data.table.wiki"}, {"project": "data.table", "id": "c6e8c2817d964bfcb91c69f3c3ab9922", "source": "data.table.wiki"}, {"project": "data.table", "id": "d0951549daae4064b92c6cd113848ba7", "source": "data.table.wiki"}, {"id": "3822987a0580402fbe1dd2992f1c6e45", "source": "data.table.wiki", "project": "data.table"}, {"id": "08e4a497362743a7880cedf66b881b1d", "source": "data.table.wiki", "project": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "11b944f32f6c45c0901f9cf5aa855631"}, {"project": "data.table", "id": "ad2e92f59bcb476aacd0457df1b1e1cf", "source": "data.table.wiki"}, {"id": "674556e8132d48879590219fa3fc203d", "project": "data.table", "source": "data.table.wiki"}, {"id": "899afafed7794241b193a68690fdc854", "source": "data.table.wiki", "project": "data.table"}, {"id": "033308f79c154de1a5787ef3d57fcf2f", "source": "data.table.wiki", "project": "data.table"}, {"id": "023a1f17887b4d2d883c0365d9fdaada", "source": "data.table.wiki", "project": "data.table"}, {"project": "data.table", "id": "f43ffef8691b44bab2cecb3ae1b1cc6f", "source": "data.table.wiki"}, {"id": "2380619177e54b53b41ffc43b4e94487", "source": "data.table.wiki", "project": "data.table"}, {"project": "data.table", "id": "71d53296b086470cb0773b318860faa0", "source": "data.table.wiki"}, {"id": "cc01fb0be3e547f68730b3ef8378242f", "project": "data.table", "source": "data.table.wiki"}, {"id": "b44a298192b443e1b800e7fb8cd416d4", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table.wiki", "project": "data.table", "id": "459c232e77ca49c39bf43b8ad7c26ca1"}, {"project": "data.table", "source": "data.table.wiki", "id": "1eb52d8f2ebe42a5a4780388f942b608"}, {"project": "data.table", "id": "15c277fbb9f7435fbedb327503876b9d", "source": "data.table.wiki"}, {"id": "b94020015b5145f98aa57b9f98d18c0d", "source": "data.table.wiki", "project": "data.table"}, {"id": "9172e59dbf624e15b86c74be7562eaf7", "source": "data.table.wiki", "project": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "b6e464a8e625487e9844c868e5df0a33"}, {"project": "data.table", "id": "55a7530c87434fea89955aea17b4e8b2", "source": "data.table.wiki"}, {"id": "32bec28871084fa68193bde5e1cc5097", "source": "data.table.wiki", "project": "data.table"}, {"id": "05cc267e5c1d4534a95499631d1f3698", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table.wiki", "id": "049782801f2346fea4b5ffa3adb3a0da", "project": "data.table"}, {"id": "6bf8661d04b44470af4c2c22c2b89c78", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table.wiki", "id": "448e73cc11e04ed7b733d0bc7c83aaca", "project": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "617534e492854f40bfd5ab6416692b41"}, {"source": "data.table.wiki", "project": "data.table", "id": "1cccabb950ef4a1ba1f9f432af54fb2f"}, {"project": "data.table", "id": "b16a6e84ef314f38b74c7aea3d86c6d8", "source": "data.table.wiki"}, {"id": "708ba6ae1f354688b105a41c1fc8385b", "project": "data.table", "source": "data.table.wiki"}, {"project": "data.table", "id": "2705e9ef6fac4d3f9229a147ebc31e80", "source": "data.table.wiki"}, {"project": "data.table", "source": "data.table.wiki", "id": "4d00fe9ff6dd4f9f9730191b004b6eac"}, {"project": "data.table", "source": "data.table.wiki", "id": "b8fc4129a85d4c0e98e4bfdf9d90df22"}, {"id": "21d909fa5fc347a08fa6a0dd06cc5945", "source": "data.table.wiki", "project": "data.table"}, {"id": "1ef528ce955f482d9b8ac46b111e275b", "project": "data.table", "source": "data.table.wiki"}, {"id": "eae0ef63a2b048c1b1d55fdeec631374", "project": "data.table", "source": "data.table.wiki"}, {"project": "data.table", "id": "853aa8d026994b9b83019b31b49faf97", "source": "data.table.wiki"}, {"project": "data.table", "id": "cf86868cd72e4753be3f3d11c6644091", "source": "data.table.wiki"}, {"id": "c1181cc002874795b904b1c75b8b0ced", "source": "data.table.wiki", "project": "data.table"}, {"source": "data.table", "project": "data.table", "id": "2254e9aa07e849cb9b0239fd5ec4e668", "file_path": ".Rbuildignore", "file_name": ".Rbuildignore"}, {"source": "data.table.wiki", "project": "data.table", "id": "ba82b5bccad04a11a891e5f5b1394628"}, {"project": "data.table", "source": "data.table.wiki", "id": "79a2ddcc01ae42db8e5fbd106e02df18"}, {"id": "bef38882087440599c9922d063abfd66", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table.wiki", "id": "01d7bb18e0e44044980b08d07437063d", "project": "data.table"}, {"id": "ccc6ae4a87a94a2986ae5055b1ce1b4e", "source": "data.table.wiki", "project": "data.table"}, {"project": "data.table", "source": "data.table.wiki", "id": "bcf9c5fe40ae48b6bff605fe65a6a658"}, {"source": "data.table.wiki", "project": "data.table", "id": "056aa1b9a5864bc280a52c2b7cf7ef50"}]} -{"timestamp": "2026-02-11T12:08:12", "session_id": "1471220254439899209", "question": "what is data.table in very very simple/beginner terms", "retrieved_context": "## Community\n\n`data.table` is widely used by the R community. It is being directly used by hundreds of CRAN and Bioconductor packages, and indirectly by thousands. It is one of the [top most starred](https://medium.datadriveninvestor.com/most-starred-and-forked-github-repos-for-r-in-data-science-fb87a54d2a6a) R packages on GitHub, and was highly rated by the [Depsy project](http://depsy.org/package/r/data.table). If you need help, the `data.table` community is active on [StackOverflow](https://stackoverflow.com/questions/tagged/data.table).\n\nA list of packages that significantly support, extend, or make use of `data.table` can be found in the [Seal of Approval](https://github.com/Rdatatable/data.table/blob/master/Seal_of_Approval.md) document.\n\n### Stay up-to-date\n\n- click the **Watch** button at the top and right of GitHub project page\n- read [NEWS file](https://github.com/Rdatatable/data.table/blob/master/NEWS.md)\n- follow [#rdatatable](https://x.com/hashtag/rdatatable) and the [r_data_table](https://x.com/r_data_table) account on X/Twitter\n- follow [#rdatatable](https://fosstodon.org/tags/rdatatable) and the [r_data_table account](https://fosstodon.org/@r_data_table) on fosstodon\n- follow the [data.table community page](https://www.linkedin.com/company/data-table-community) on LinkedIn\n- watch recent [Presentations](https://github.com/Rdatatable/data.table/wiki/Presentations)\n- read recent [Articles](https://github.com/Rdatatable/data.table/wiki/Articles)\n- read posts on [The Raft](https://rdatatable-community.github.io/The-Raft/)\n\n### Contributing\n\nGuidelines for filing issues / pull requests: [Contribution Guidelines](https://github.com/Rdatatable/data.table/blob/master/.github/CONTRIBUTING.md).\n\n---\n\n# Seal of Approval\n\nThis is a list of packages in the `data.table` community.\n\nFurther detail about these packages and their relationship to `data.table` can be found at [The Raft blog](https://rdatatable-community.github.io/The-Raft/#category=seal%20of%20approval).\n\nTo add your package to this list, please [submit a Pull Request to The Raft](https://github.com/rdatatable-community/The-Raft/), making sure to follow the templated instructions.\n\n## Extension packages\n\nAdds to the internal functionality of `data.table`.\n\n- [nc](https://github.com/tdhock/nc): Named capture regular expressions for text parsing and data reshaping.\n\n## Application packages\n\nUses `data.table` to accomplish a particular task or analysis.\n\n- [mlr3](https://github.com/mlr-org/mlr3): A versatile machine learning framework built on data.table.\n\n## Bridge packages\n\nTranslates `data.table` syntax to a different syntax, or provides helper functions for transitioning between `data.table` and another object type.\n\n- [tidyfast](https://github.com/TysonStanley/tidyfast): Fast and efficient alternatives to tidyr functions built on `data.table`.\n\n- [dtplyr](https://github.com/tidyverse/dtplyr): A `data.table` backend for `dplyr`.\n\n## Partner packages\n\nNot necessarily directly connected to `data.table`, but deliberately follows the [core philosophies of `data.table`](https://github.com/Rdatatable/data.table/blob/master/GOVERNANCE.md#the-r-package).\n\n- [collapse](https://github.com/SebKrantz/collapse): Advanced and Fast Data Transformation in R.\n\n---\n\nPackage: data.table\nVersion: 1.18.99\nTitle: Extension of `data.frame`\nDepends: R (>= 3.5.0)\nImports: methods\nSuggests: bit64 (>= 4.0.0), R.utils, xts, zoo (>= 1.8-1), yaml, litedown, codetools\nEnhances: knitr, xfun\nDescription: Fast aggregation of large data (e.g. 100GB in RAM), fast ordered joins, fast add/modify/delete of columns by group using no copies at all, list columns, friendly and fast character-separated-value read/write. Offers a natural and flexible syntax, for faster development.\nLicense: MPL-2.0 | file LICENSE\nURL: https://r-datatable.com, https://Rdatatable.gitlab.io/data.table, https://github.com/Rdatatable/data.table\nBugReports: https://github.com/Rdatatable/data.table/issues\nVignetteBuilder: litedown\nEncoding: UTF-8\nByteCompile: TRUE\nAuthors@R: c(\n person(\"Tyson\",\"Barrett\", role=c(\"aut\",\"cre\"), email=\"t.barrett88@gmail.com\", comment = c(ORCID=\"0000-0002-2137-1391\")),\n person(\"Matt\",\"Dowle\", role=\"aut\", email=\"mattjdowle@gmail.com\"),\n person(\"Arun\",\"Srinivasan\", role=\"aut\", email=\"asrini@pm.me\"),\n person(\"Jan\",\"Gorecki\", role=\"aut\", email=\"j.gorecki@wit.edu.pl\"),\n person(\"Michael\",\"Chirico\", role=\"aut\", email=\"michaelchirico4@gmail.com\", comment = c(ORCID=\"0000-0003-0787-087X\")),\n person(\"Toby\",\"Hocking\", role=\"aut\", email=\"toby.hocking@r-project.org\", comment = c(ORCID=\"0000-0002-3146-0865\")),\n person(\"Benjamin\",\"Schwendinger\",role=\"aut\", comment = c(ORCID=\"0000-0003-3315-8114\")),\n person(\"Ivan\", \"Krylov\", role=\"aut\", email=\"ikrylov@disroot.org\", comment = c(ORCID=\"0000-0002-0172-3812\")),\n person(\"Pasha\",\"Stetsenko\", role=\"ctb\"),\n person(\"Tom\",\"Short\", role=\"ctb\"),\n person(\"Steve\",\"Lianoglou\", role=\"ctb\"),\n person(\"Eduard\",\"Antonyan\", role=\"ctb\"),\n person(\"Markus\",\"Bonsch\", role=\"ctb\"),\n person(\"Hugh\",\"Parsonage\", role=\"ctb\"),\n person(\"Scott\",\"Ritchie\", role=\"ctb\"),\n person(\"Kun\",\"Ren\", role=\"ctb\"),\n person(\"Xianying\",\"Tan\", role=\"ctb\"),\n person(\"Rick\",\"Saporta\", role=\"ctb\"),\n person(\"Otto\",\"Seiskari\", role=\"ctb\"),\n person(\"Xianghui\",\"Dong\", role=\"ctb\"),\n person(\"Michel\",\"Lang\", role=\"ctb\"),\n person(\"Watal\",\"Iwasaki\", role=\"ctb\"),\n person(\"Seth\",\"Wenchel\", role=\"ctb\"),\n person(\"Karl\",\"Broman\", role=\"ctb\"),\n person(\"Tobias\",\"Schmidt\", role=\"ctb\"),\n person(\"David\",\"Arenburg\", role=\"ctb\"),\n person(\"Ethan\",\"Smith\", role=\"ctb\"),\n person(\"Francois\",\"Cocquemas\", role=\"ctb\"),\n person(\"Matthieu\",\"Gomez\", role=\"ctb\"),\n person(\"Philippe\",\"Chataignon\", role=\"ctb\"),\n person(\"Nello\",\"Blaser\", role=\"ctb\"),\n person(\"Dmitry\",\"Selivanov\", role=\"ctb\"),\n person(\"Andrey\",\"Riabushenko\", role=\"ctb\"),\n person(\"Cheng\",\"Lee\", role=\"ctb\"),\n person(\"Declan\",\"Groves\", role=\"ctb\"),\n person(\"Daniel\",\"Possenriede\", role=\"ctb\"),\n person(\"Felipe\",\"Parages\", role=\"ctb\"),\n person(\"Denes\",\"Toth\", role=\"ctb\"),\n person(\"Mus\",\"Yaramaz-David\", role=\"ctb\"),\n person(\"Ayappan\",\"Perumal\", role=\"ctb\"),\n person(\"James\",\"Sams\", role=\"ctb\"),\n person(\"Martin\",\"Morgan\", role=\"ctb\"),\n person(\"Michael\",\"Quinn\", role=\"ctb\"),\n person(given=\"@javrucebo\", role=\"ctb\", comment=\"GitHub user\"),\n person(\"Marc\",\"Halperin\", role=\"ctb\"),\n person(\"Roy\",\"Storey\", role=\"ctb\"),\n person(\"Manish\",\"Saraswat\", role=\"ctb\"),\n person(\"Morgan\",\"Jacob\", role=\"ctb\"),\n person(\"Michael\",\"Schubmehl\", role=\"ctb\"),\n person(\"Davis\",\"Vaughan\", role=\"ctb\"),\n person(\"Leonardo\",\"Silvestri\", role=\"ctb\"),\n person(\"Jim\",\"Hester\", role=\"ctb\"),\n person(\"Anthony\",\"Damico\", role=\"ctb\"),\n person(\"Sebastian\",\"Freundt\", role=\"ctb\"),\n person(\"David\",\"Simons\", role=\"ctb\"),\n person(\"Elliott\",\"Sales de Andrade\", role=\"ctb\"),\n\n---\n\nIf you face any problems in creating a package that uses data.table, please confirm that the problem is reproducible in a clean R session using the R console: `R CMD check package.name`.\n\nSome of the most common issues developers are facing are usually related to helper tools that are meant to automate some package development tasks, for example, using `roxygen` to generate your `NAMESPACE` file from metadata in the R code files. Others are related to helpers that build and check the package. Unfortunately, these helpers sometimes have unintended/hidden side effects which can obscure the source of your troubles. As such, be sure to double check using R console (run R on the command line) and ensure the import is defined in the `DESCRIPTION` and `NAMESPACE` files following the [instructions](#DESCRIPTION) [above](#NAMESPACE).\n\nIf you are not able to reproduce problems you have using the plain R console build and check, you may try to get some support based on past issues we've encountered with `data.table` interacting with helper tools: [devtools#192](https://github.com/r-lib/devtools/issues/192) or [devtools#1472](https://github.com/r-lib/devtools/issues/1472).\n\n## License\n\nSince version 1.10.5 `data.table` is licensed as Mozilla Public License (MPL). The reasons for the change from GPL should be read in full [here](https://github.com/Rdatatable/data.table/pull/2456) and you can read more about MPL on Wikipedia [here](https://en.wikipedia.org/wiki/Mozilla_Public_License) and [here](https://en.wikipedia.org/wiki/Comparison_of_free_and_open-source_software_licenses).\n\n## Optionally import `data.table`: Suggests\n\nIf you want to use `data.table` conditionally, i.e., only when it is installed, you should use `Suggests: data.table` in your `DESCRIPTION` file instead of using `Imports: data.table`. By default this definition will not force installation of `data.table` when installing your package. This also requires you to conditionally use `data.table` in your package code which should be done using the `?requireNamespace` function. The below example demonstrates conditional use of `data.table`'s fast CSV writer `?fwrite`. If the `data.table` package is not installed, the much-slower base R `?write.table` function is used instead.\n\n```r\nmy.write = function (x) {\n if(requireNamespace(\"data.table\", quietly=TRUE)) {\n data.table::fwrite(x, \"data.csv\")\n } else {\n write.table(x, \"data.csv\")\n }\n}\n```\n\nA slightly more extended version of this would also ensure that the installed version of `data.table` is recent enough to have the `fwrite` function available:\n\n```r\nmy.write = function (x) {\n if(requireNamespace(\"data.table\", quietly=TRUE) &&\n utils::packageVersion(\"data.table\") >= \"1.9.8\") {\n data.table::fwrite(x, \"data.csv\")\n } else {\n write.table(x, \"data.csv\")\n }\n}\n```\n\nWhen using a package as a suggested dependency, you should not `import` it in the `NAMESPACE` file. Just mention it in the `DESCRIPTION` file.\nWhen using `data.table` functions in package code (R/* files) you need to use the `data.table::` prefix because none of them are imported.\nWhen using `data.table` in package tests (e.g. tests/testthat/test* files), you need to declare `.datatable.aware=TRUE` in one of the R/* files.\n\n## `data.table` in `Imports` but nothing imported\n\nSome users ([e.g.](https://github.com/Rdatatable/data.table/issues/2341)) may prefer to eschew using `importFrom` or `import` in their `NAMESPACE` file and instead use `data.table::` qualification on all internal code (of course keeping `data.table` under their `Imports:` in `DESCRIPTION`).\n\n---\n\nR data.table FAQ vignette has been converted to Rmarkdown format and can be found here. It is also shipped together with data.table package, so it can be accessed locally using vignette(\"datatable-faq\", package=\"data.table\").\n\n---\n\n# Governance for the R data.table project\n\n# Purpose and scope\n\n## This document\n\nThe purpose of this document is to define how people related to the project work together, so that the project can expand to handle a larger and more diverse group of contributors.\n\n## The R package\n\nThe purpose of the project is to maintain the R data.table package, which is guided by the following principles:\n\n* Time & memory efficiency\n* Concise syntax (minimal redundancy in code)\n* No external Imports/LinkingTo/Depends dependencies (external meaning those not maintained by the project)\n* Few (if any) Suggests/Enhances dependencies\n* Stable code base (strong preference for user-friendly back-compatibility with data.table itself and with old versions of R)\n* Comprehensive and accessible documentation and run-time signals (errors, warnings)\n\nTo prioritize developer time, we define what is in and out of current scope. Feature requests in issues and pull requests that are out of current scope should be closed immediately, because they are not the current priority. If someone wants to contribute code that is currently out of scope, they first have to make a pull request that changes the scope as defined below.\n\nThe current scope of package functionality includes:\n* data manipulation and analysis \n * reshaping/pivoting\n * aggregation/summarizing (via `[,, by=...]` and _grouping sets_)\n * filtering rows\n * all sorts of joins\n * adding/updating/deleting columns\n * set operations (union/rbind, intersection, difference)\n* high-performance common functions (`frank`, `fcase`, `fifelse`, `transpose`, `chmatch`, `fsort`, `forder`, `uniqueN`, ...)\n* common convenience functions (`%like%`, `%notin%`, `timetaken`, `substitute2`, ...)\n* ordered data functions (`rleid`, `shift`, `fcoalesce`, _locf_/_nocb_ `nafill`, rolling functions)\n* date and time related classes and functions (`IDate`, `ITime`)\n* technical functions (`address`, `tables`, `update_dev_pkg`)\n* Reading/writing of data from/to flat (plain text) files like CSV\n\nFunctionality that is out of current scope:\n* Plotting/graphics (like ggplot2)\n* Manipulating out-of-memory data, e.g. data stored on disk or remote SQL DB, (as opposed e.g. to sqldf / dbplyr)\n* Machine learning (like mlr3)\n* Reading/writing of data from/to binary files like parquet\n\n# Roles \n\n## Contributor\n\n* Definition: a user who has written/commented at least one issue, worked to label/triage issues, written a blog post, given a talk, etc. \n* How this role is recognized: there is no central list of Contributors / no formal recognition for Contributors.\n\n## Project Member\n\n* Definition: some one who has submitted at least one PR with substantial contributions, that has been merged into master. PRs improving documentation are welcome, and substantial contributions to the docs should count toward Project Membership, but minor contributions such as spelling fixes do not count toward Project Membership.\n* How to obtain this role: anybody can become a Project Member by submitting a PR with substantial contributions, then having it reviewed and merged into master. Contributors who have written issues should be encouraged to submit their first PR to become a Project Member. Contributors can look at https://github.com/Rdatatable/data.table/labels/beginner-task for easy issues to work on.\n* How this role is recognized: Project Members are credited via role=\"ctb\" in DESCRIPTION (so they appear in Author list on CRAN), and they are added to https://github.com/orgs/Rdatatable/teams/project-members so they can create new branches in the Rdatatable/data.table GitHub repo. They also appear on https://github.com/Rdatatable/data.table/graphs/contributors (Contributions to master, excluding merge commits).\n\n## Reviewer\n\n---\n\nProvide an external link to the minimal reproducible file and use that file name in your code.\n\nLook at closed issues. Observe the good and the bad.\n\nType ?data.table and look at all the arguments. Do you know them all? For example, do you know which= and others? Make sure you do. It is likely that one of them is there for your task. If some seem like they could help, search Stack Overflow for that argument name within the [data.table] tag and see how people have used it. Many answers use data.table but the question was not about data.table, so in this situation search in the [r] tag (not [data.table]) for the \"data.table\" and the argument name.\n\nRead all the vignettes.\n\nRead all the questions in the data.table FAQ even if you don't have those questions yet.\n\nTake the Datacamp course\n\nBest wishes!\n\n---\n\n\\name{data.table-package}\n\\alias{data.table-package}\n\\docType{package}\n\\alias{data.table}\n\\alias{Ops.data.table}\n\\alias{is.na.data.table}\n\\alias{[.data.table}\n\\alias{.}\n\\alias{.(}\n\\alias{.()}\n\\alias{..}\n\\title{ Enhanced data.frame }\n\\description{\n \\code{data.table} \\emph{inherits} from \\code{data.frame}. It offers fast and memory efficient: file reader and writer, aggregations, updates, equi, non-equi, rolling, range and interval joins, in a short and flexible syntax, for faster development.\n\n It is inspired by \\code{A[B]} syntax in \\R where \\code{A} is a matrix and \\code{B} is a 2-column matrix. Since a \\code{data.table} \\emph{is} a \\code{data.frame}, it is compatible with \\R functions and packages that accept \\emph{only} \\code{data.frame}s.\n\n Type \\code{vignette(package=\"data.table\")} to get started. The \\href{../doc/datatable-intro.html}{Introduction to data.table} vignette introduces \\code{data.table}'s \\code{x[i, j, by]} syntax and is a good place to start. If you have read the vignettes and the help page below, please read the \\href{https://github.com/Rdatatable/data.table/wiki/Support}{data.table support guide}.\n\n Please check the \\href{https://github.com/Rdatatable/data.table/wiki}{homepage} for up to the minute live NEWS.\n\n Tip: one of the \\emph{quickest} ways to learn the features is to type \\code{example(data.table)} and study the output at the prompt.\n}\n\\usage{\ndata.table(\\dots, keep.rownames=FALSE, check.names=FALSE, key=NULL, stringsAsFactors=FALSE)\n\n\\method{[}{data.table}(x, i, j, by, keyby, with = TRUE,\n nomatch = NA,\n mult = \"all\",\n roll = FALSE,\n rollends = if (roll==\"nearest\") c(TRUE,TRUE)\n else if (roll>=0) c(FALSE,TRUE)\n else c(TRUE,FALSE),\n which = FALSE,\n .SDcols,\n verbose = getOption(\"datatable.verbose\"), # default: FALSE\n allow.cartesian = getOption(\"datatable.allow.cartesian\"), # default: FALSE\n drop = NULL, on = NULL, env = NULL, \n showProgress = getOption(\"datatable.showProgress\", interactive()))\n}\n\\arguments{\n \\item{\\dots}{ Just as \\code{\\dots} in \\code{\\link{data.frame}}. Usual recycling rules are applied to vectors of different lengths to create a list of equal length vectors.}\n\n \\item{keep.rownames}{ If \\code{\\dots} is a \\code{matrix} or \\code{data.frame}, \\code{TRUE} will retain the rownames of that object in a column named \\code{rn}.}\n\n \\item{check.names}{ Just as \\code{check.names} in \\code{\\link{data.frame}}.}\n\n \\item{key}{ Character vector of one or more column names which is passed to \\code{\\link{setkey}}.}\n\n \\item{stringsAsFactors}{Logical (default is \\code{FALSE}). Convert all \\code{character} columns to \\code{factor}s?}\n\n \\item{x}{ A \\code{data.table}.}\n\n \\item{i}{ Integer, logical or character vector, single column numeric \\code{matrix}, expression of column names, \\code{list}, \\code{data.frame} or \\code{data.table}.\n\n \\code{integer} and \\code{logical} vectors work the same way they do in \\code{\\link{[.data.frame}} except logical \\code{NA}s are treated as FALSE.\n\n \\code{expression} is evaluated within the frame of the \\code{data.table} (i.e. it sees column names as if they are variables) and can evaluate to any of the other types.\n\n \\code{character}, \\code{list} and \\code{data.frame} input to \\code{i} is converted into a \\code{data.table} internally using \\code{\\link{as.data.table}}.\n\n If \\code{i} is a \\code{data.table}, the columns in \\code{i} to be matched against \\code{x} can be specified using one of these ways:\n\n \\itemize{\n \\item \\code{on} argument (see below). It allows for both \\code{equi-} and the newly implemented \\code{non-equi} joins.\n\n \\item If not, \\code{x} \\emph{must be keyed}. Key can be set using \\code{\\link{setkey}}. If \\code{i} is also keyed, then first \\emph{key} column of \\code{i} is matched against first \\emph{key} column of \\code{x}, second against second, etc..\n\n---\n\nIn this case, the un-exported function `[.data.table` will revert to calling `[.data.frame` as a safeguard since `data.table` has no way of knowing that the parent package is aware it's attempting to make calls against the syntax of `data.table`'s query API (which could lead to unexpected behavior as the structure of calls to `[.data.frame` and `[.data.table` fundamentally differ, e.g. the latter has many more arguments).\n\nIf this is anyway your preferred approach to package development, please define `.datatable.aware = TRUE` anywhere in your R source code (no need to export). This tells `data.table` that you as a package developer have designed your code to intentionally rely on `data.table` functionality even though it may not be obvious from inspecting your `NAMESPACE` file.\n\n`data.table` determines on the fly whether the calling function is aware it's tapping into `data.table` with the internal `cedta` function (**C**alling **E**nvironment is **D**ata **T**able **A**ware), which, beyond checking the `?getNamespaceImports` for your package, also checks the existence of this variable (among other things).\n\n## Further information on dependencies\n\nFor more canonical documentation of defining packages dependency check the official manual: [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html).\n\n## Importing data.table C routines\n\nSome of internally used C routines are now exported on C level thus can be used in R packages directly from their C code. See [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) for details and [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) _Linking to native routines in other packages_ section for usage.\n\n## Importing from non-r Applications {#non-r-api}\n\nSome tiny parts of `data.table` C code were isolated from the R C API and can now be used from non-R applications by linking to .so / .dll files. More concrete details about this will be provided later; for now you can study the C code that was isolated from the R C API in [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) and [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c).\n\n## How to convert your Depends dependency on data.table to Imports\n\nTo convert a `Depends` dependency on `data.table` to an `Imports` dependency in your package, follow these steps:\n\n### Step 0. Ensure your package is passing R CMD check initially\n\n### Step 1. Update the DESCRIPTION file to put data.table in Imports, not Depends\n\n**Before:**\n```dcf\nDepends:\n R (>= 3.5.0),\n data.table\nImports:\n```\n\n**After:**\n```dcf\nDepends:\n R (>= 3.5.0)\nImports:\n data.table\n```\n\n### Step 2.1: Run `R CMD check`\n\nRun `R CMD check` to identify any missing imports or symbols. This step helps:\n\n- Automatically detect any functions or symbols from `data.table` that are not explicitly imported.\n- Flag missing special symbols like `.N`, `.SD`, and `:=`.\n- Provide immediate feedback on what needs to be added to the NAMESPACE file.\n\nNote: Not all such usages are caught by `R CMD check`. In particular, `R CMD check` skips some symbols/functions in formulas and will completely miss parsed expressions like `parse(text = \"data.table(a = 1)\")`. Packages will need good test coverage to detect these edge cases.\n\n### Step 2.2: Modify the NAMESPACE file\n\nBased on the `R CMD check` results, ensure all used functions, special symbols, S3 generics, and S4 classes from `data.table` are imported.\n\nThat means adding `importFrom(data.table, ...)` directives for symbols, functions, and S3 generics, and/or `importClassesFrom(data.table, ...)` directives for S4 classes as appropriate. See 'Writing R Extensions' for full details on how to do so properly.\n\n#### Blanket import\n\nAlternatively, you can import all functions from `data.table` at once, though this is generally not recommended:\n\n```r\nimport(data.table)\n```\n\n---\n\nThe case for `data.table`'s special symbols (e.g. `.SD` and `.N`) and assignment operator (`:=`) is slightly different (see `?.N` for more, including a complete listing of such symbols). You should import whichever of these values you use from `data.table`'s namespace to protect against any issues arising from the unlikely scenario that we change the exported value of these in the future, e.g. if you want to use `.N`, `.I`, and `:=`, a minimal `NAMESPACE` would have:\n\n```r\nimportFrom(data.table, .N, .I, ':=')\n```\n\nMuch simpler is to just use `import(data.table)` which will greedily allow usage in your package's code of any object exported from `data.table`.\n\nIf you don't mind having `id` and `grp` registered as variables globally in your package namespace you can use `?globalVariables`. Be aware that these notes do not have any impact on the code or its functionality; if you are not going to publish your package, you may simply choose to ignore them.\n\n## Care needed when providing and using options\n\nCommon practice by R packages is to provide customization options set by `options(name=val)` and fetched using `getOption(\"name\", default)`. Function arguments often specify a call to `getOption()` so that the user knows (from `?fun` or `args(fun)`) the name of the option controlling the default for that parameter; e.g. `fun(..., verbose=getOption(\"datatable.verbose\", FALSE))`. All `data.table` options start with `datatable.` so as to not conflict with options in other packages. A user simply calls `options(datatable.verbose=TRUE)` to turn on verbosity. This affects all data.table function calls unless `verbose=FALSE` is provided explicitly; e.g. `fun(..., verbose=FALSE)`.\n\nThe option mechanism in R is _global_. Meaning that if a user sets a `data.table` option for their own use, that setting also affects code inside any package that is using `data.table` too. For an option like `datatable.verbose`, this is exactly the desired behavior since the desire is to trace and log all `data.table` operations from wherever they originate; turning on verbosity does not affect the results. Another unique-to-R and excellent-for-production option is R's `options(warn=2)` which turns all warnings into errors. Again, the desire is to affect any warning in any package so as to not miss any warnings in production. There are 6 `datatable.print.*` options and 3 optimization options which do not affect the result of operations. However, there is one `data.table` option that does and is now a concern: `datatable.nomatch`. This option changes the default join from outer to inner. [Aside, the default join is outer because outer is safer; it doesn't drop missing data silently; moreover it is consistent to base R way of matching by names and indices.] Some users prefer inner join to be the default and we provided this option for them. However, a user setting this option can unintentionally change the behavior of joins inside packages that use `data.table`. Accordingly, in v1.12.4 (Oct 2019) a message was printed when the `datatable.nomatch` option was used, and from v1.14.2 it is now ignored with warning. It was the only `data.table` option with this concern.\n\n## Troubleshooting\n\nIf you face any problems in creating a package that uses data.table, please confirm that the problem is reproducible in a clean R session using the R console: `R CMD check package.name`.\n\n---\n\nLIBRARY data.table.dll\nEXPORTS\n R_init_data_table\n\n---\n\n## Importe optionnellement `data.table` : `Suggests`\n\nSi vous voulez utiliser `data.table` de manière conditionnelle, c'est-à-dire seulement quand il est installé, vous devriez utiliser `Suggests: data.table` dans votre fichier `DESCRIPTION` au lieu d'utiliser `Imports: data.table`. Par défaut, cette définition ne forcera pas l'installation de `data.table` lors de l'installation de votre package. Cela vous oblige aussi à utiliser conditionnellement `data.table` dans le code de votre package, ce qui doit être fait en utilisant la fonction `?requireNamespace`. L'exemple ci-dessous démontre l'utilisation conditionnelle de la fonction d'écriture de CSV rapide de `?fwrite` du package `data.table`. Si le package `data.table` n'est pas installé, la fonction de base R `?write.table`, beaucoup plus lente, est utilisée à la place.\n\n```r\nmy.write = function (x) {\n if(requireNamespace(\"data.table\", quietly=TRUE)) {\n data.table::fwrite(x, \"data.csv\")\n } else {\n write.table(x, \"data.csv\")\n }\n}\n```\n\nUne version légèrement plus étendue de cette méthode permettrait également de s'assurer que la version installée de `data.table` est suffisamment récente pour que la fonction `fwrite` soit disponible :\n\n```r\nmy.write = function (x) {\n if(requireNamespace(\"data.table\", quietly=TRUE) &&\n utils::packageVersion(\"data.table\") >= \"1.9.8\") {\n data.table::fwrite(x, \"data.csv\")\n } else {\n write.table(x, \"data.csv\")\n }\n}\n```\n\nLorsque vous utilisez un package comme dépendance suggérée, vous ne devez pas l'\"importer\" dans le fichier `NAMESPACE`. Mentionnez-le simplement dans le fichier `DESCRIPTION`. Lorsque vous utilisez les fonctions `data.table` dans le code d'un package (fichiers R/*), vous devez utiliser le préfixe `data.table::` car aucune d'entre elles n'est importée. Lorsque vous utilisez `data.table` dans des packages de tests (par exemple des fichiers tests/testthat/test*), vous devez déclarer `.datatable.aware=TRUE` dans l'un des fichiers R/*.\n\n## `data.table` dans `Imports` mais rien d'importé\n\nCertains utilisateurs ([e.g.](https://github.com/Rdatatable/data.table/issues/2341)) peuvent préférer éviter d'utiliser `importFrom` ou `import` dans leur fichier `NAMESPACE` et utiliser à la place la syntaxe `data.table::` sur tout le code interne (en gardant bien sûr `data.table` sous leurs `Imports:` dans `DESCRIPTION`).\n\nDans ce cas, la fonction non exportée `[.data.table` reviendra à appeler `[.data.frame` comme filet de sécurité puisque `data.table` n'a aucun moyen de savoir que le package parent est conscient qu'il tente de faire des appels en utilisant la syntaxe de l'API de requête de `data.table` (ce qui pourrait conduire à un comportement inattendu car la structure des appels à `[.data.frame` et `[.data.table` diffère fondamentalement, par exemple, ce dernier a beaucoup plus d'arguments).\n\nSi c'est l'approche que vous préférez pour le développement de packages, définissez `.datatable.aware = TRUE` n'importe où dans votre code source R (pas besoin d'exporter). Cela indique à `data.table` que vous, en tant que développeur du package, avez conçu votre code pour qu'il s'appuie intentionnellement sur les fonctionnalités de `data.table`, même si cela n'est pas évident en inspectant votre fichier `NAMESPACE`.\n\n`data.table` détermine à la volée si la fonction appelante est consciente qu'elle puise dans `data.table` avec la fonction interne `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), qui, en plus de vérifier le `?getNamespaceImports` de votre package, vérifie également l'existence de cette variable (entre autres choses).\n\n## Plus d'informations sur les dépendances\n\nPour une documentation plus canonique sur la définition de la dépendance des packages, consultez le manuel officiel : [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html).\n\n## Importation des routines C de data.table\n\n---\n\n### NOTES\n\n 1. Clearer explanation of what `duplicated()` does (borrowed from base). Thanks to @matthieugomez for pointing out. Closes [#872](https://github.com/Rdatatable/data.table/issues/872).\n\n 2. `?setnames` has been updated now that `names<-` and `colnames<-` shallow (rather than deep) copy from R >= 3.1.0, [#853](https://github.com/Rdatatable/data.table/issues/853).\n\n 3. [FAQ 1.6](https://github.com/Rdatatable/data.table/wiki/vignettes/datatable-faq.pdf) has been embellished, [#517](https://github.com/Rdatatable/data.table/issues/517). Thanks to a discussion with Vivi and Josh O'Brien.\n\n 4. `data.table` redefines `melt` generic and *suggests* `reshape2` instead of *import*. As a result we don't have to load `reshape2` package to use `melt.data.table` anymore. The reason for this change is that `data.table` requires R >=2.14, whereas `reshape2` R v3.0.0+. Reshape2's melt methods can be used without any issues by loading the package normally.\n\n 5. `DT[, j, ]` at times made an additional (unnecessary) copy. This is now fixed. This fix also avoids allocating `.I` when `j` doesn't use it. As a result `:=` and other subset operations should be faster (and use less memory). Thanks to @szilard for the nice report. Closes [#921](https://github.com/Rdatatable/data.table/issues/921).\n\n 6. Because `reshape2` requires R >3.0.0, and `data.table` works with R >= 2.14.1, we can not import `reshape2` anymore. Therefore we define a `melt` generic and `melt.data.table` method for data.tables and redirect to `reshape2`'s `melt` for other objects. This is to ensure that existing code works fine.\n\n 7. `dcast` is also a generic now in data.table. So we can use `dcast(...)` directly, and don't have to spell it out as `dcast.data.table(...)` like before. The `dcast` generic in data.table redirects to `reshape2::dcast` if the input object is not a data.table. But for that you have to load `reshape2` before loading `data.table`. If not, reshape2's `dcast` overwrites data.table's `dcast` generic, in which case you will need the `::` operator - ex: `data.table::dcast(...)`.\n\n NB: Ideal situation would be for `dcast` to be a generic in reshape2 as well, but it is not. We have issued a [pull request](https://github.com/hadley/reshape/pull/62) to make `dcast` in reshape2 a generic, but that has not yet been accepted.\n\n 8. Clarified the use of `bit64::integer4` in `merge.data.table()` and `setNumericRounding()`. Closes [#1093](https://github.com/Rdatatable/data.table/issues/1093). Thanks to @sfischme for the report.\n\n 9. Removed an unnecessary (and silly) `giveNames` argument from `setDT()`. Not sure why I added this in the first place!\n\n 10. `options(datatable.prettyprint.char=5L)` restricts the number of characters to be printed for character columns. For example:\n ```\n options(datatable.prettyprint.char = 5L)\n DT = data.table(x=1:2, y=c(\"abcdefghij\", \"klmnopqrstuv\"))\n DT\n # x y\n # 1: 1 abcde...\n # 2: 2 klmno...\n ````\n\n 11. `rolltolast` argument in `[.data.table` is now defunct. It was deprecated in 1.9.4.\n\n 12. `data.table`'s dependency has been moved forward from R 2.14.0 to R 2.14.1, now nearly 4 years old (Dec 2011). As usual before release to CRAN we ensure data.table passes the test suite on the stated dependency and keep this as old as possible for as long as possible. As requested by users in managed environments. For this reason we still don't use `paste0()` internally, since that was added to R 2.15.0.\n\n 13. Warning about `datatable.old.bywithoutby` option (for grouping on join without providing `by`) being deprecated in the next release is in place now. Thanks to @jangorecki for the PR.\n\n 14. Fixed `allow.cartesian` documentation to `nrow(x)+nrow(i)` instead of `max(nrow(x), nrow(i))`. Closes [#1123](https://github.com/Rdatatable/data.table/issues/1123).\n\n## data.table v1.9.4 (on CRAN 2 Oct 2014)\n\n### NEW FEATURES\n\n---\n\n## Importation des routines C de data.table\n\nCertaines routines C utilisées en interne sont maintenant exportées au niveau C et peuvent donc être utilisées dans les packages R directement à partir de leur code C. Voir [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) pour les détails et [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) dans la section *Linking to native routines in other packages* pour l'utilisation.\n\n## Importation à partir d'applications non-r {#non-r-api}\n\nCertaines petites parties du code C de `data.table` ont été isolées de l'API C de R et peuvent maintenant être utilisées à partir d'applications non-R en liant les fichiers .so / .dll. Des détails plus concrets seront fournis ultérieurement ; pour l'instant, vous pouvez étudier le code C qui a été isolé de l'API C de R dans [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) et [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c).\n\n## Comment convertir votre dépendance à data.table de Depends à Imports\n\nPour convertir une dépendance `Depends` sur `data.table` en une dépendance `Imports` dans votre package, suivez ces étapes :\n\n### Étape 0. S'assurer que votre package passe le contrôle R CMD dans un premier temps\n\n### Étape 1. Mettre à jour le fichier DESCRIPTION pour placer data.table dans Imports, et non dans Depends\n\n**Avant :**\n\n```dcf\nDepends:\n R (>= 3.5.0),\n data.table\nImports:\n```\n\n**Après :**\n\n```dcf\nDepends:\n R (>= 3.5.0)\nImports:\n data.table\n```\n\n### Étape 2.1 : Exécuter `R CMD check`\n\nLancez `R CMD check` pour identifier tout import ou symbole manquant. Cette étape aide à :\n\n- Détecter automatiquement toutes les fonctions ou symboles de `data.table` qui ne sont pas explicitement importés.\n- Signaler les symboles spéciaux manquants comme `.N`, `.SD`, et `:=`.\n- Fournir immédiatement une information sur ce qui doit être ajouté au fichier NAMESPACE.\n\nNote : Toutes ces utilisations ne sont pas prises en compte par `R CMD check`. En particulier, `R CMD check` ne tient pas compte de certains symboles/fonctions dans les formules et manquera complètement des expressions analysées comme `parse(text = \"data.table(a = 1)\")`. Les packages auront besoin d'une bonne couverture de test pour détecter ces cas limites.\n\n### Étape 2.2 : Modifier le fichier NAMESPACE\n\nEn se basant sur les résultats du `R CMD check`, s'assurer que toutes les fonctions utilisées, les symboles spéciaux, les génériques S3, et les classes S4 de `data.table` sont importés.\n\nCela signifie qu'il faut ajouter les directives `importFrom(data.table, ...)` pour les symboles, les fonctions et les génériques S3, et/ou les directives `importClassesFrom(data.table, ...)` pour les classes S4, selon le cas. Voir 'Writing R Extensions' pour plus de détails sur la façon de procéder.\n\n#### Importation complète\n\nVous pouvez également importer toutes les fonctions de `data.table` en une seule fois, bien que cela ne soit généralement pas recommandé :\n\n```r\nimport(data.table)\n```\n\n**Justification Pour Eviter Les Importations Globales :** =====1. **Documentation** : Le fichier NAMESPACE peut servir de bonne documentation sur la façon dont vous dépendez de certains packages.\n2. **Éviter Les Conflits** : Les importations générales vous exposent à des ruptures subtiles. Par exemple, si vous importez deux packages avec `import(pkgA)` et `import(pkgB)`, mais que plus tard pkgB exporte une fonction également exportée par pkgA, cela cassera votre package à cause de conflits dans votre espace de noms, ce qui est interdit par `R CMD check` et CRAN.=====\n\n### Étape 3 : Mettre à jour vos fichiers de code R en dehors du répertoire R/ du package\n\n---\n\nit means that R is looking for a DLL for the modified data.table package, for a specific version, but it can't find it. The fix is to provide pkg.edit.fun which is defined here https://github.com/Rdatatable/data.table/blob/master/.ci/atime/tests.R\n\nRequested object could not be found\n\nWhen running atime_versions to prototype a new performance test, as in the code below:\n\n## Adapted from https://github.com/Rdatatable/data.table/issues/6662#issue-2737165196\nalist <- atime::atime_versions(\n \"~/R/data.table\",\n pkg.edit.fun = function(old.Package, new.Package, sha, new.pkg.path) {\n pkg_find_replace <- function(glob, FIND, REPLACE) {\n atime::glob_find_replace(file.path(new.pkg.path, glob), FIND, REPLACE)\n }\n Package_regex <- gsub(\".\", \"_?\", old.Package, fixed = TRUE)\n Package_ <- gsub(\".\", \"_\", old.Package, fixed = TRUE)\n new.Package_ <- paste0(Package_, \"_\", sha)\n pkg_find_replace(\n \"DESCRIPTION\",\n paste0(\"Package:\\\\s+\", old.Package),\n paste(\"Package:\", new.Package))\n pkg_find_replace(\n file.path(\"src\", \"Makevars.*in\"),\n Package_regex,\n new.Package_)\n pkg_find_replace(\n file.path(\"R\", \"onLoad.R\"),\n Package_regex,\n new.Package_)\n pkg_find_replace(\n file.path(\"R\", \"onLoad.R\"),\n sprintf('packageVersion\\\\(\"%s\"\\\\)', old.Package),\n sprintf('packageVersion\\\\(\"%s\"\\\\)', new.Package))\n pkg_find_replace(\n file.path(\"src\", \"init.c\"),\n paste0(\"R_init_\", Package_regex),\n paste0(\"R_init_\", gsub(\"[.]\", \"_\", new.Package_)))\n # allow compilation on new R versions where 'Calloc' is not defined\n pkg_find_replace(\n file.path(\"src\", \"*.c\"),\n \"\\\\b(Calloc|Free|Realloc)\\\\b\",\n \"R_\\\\1\")\n pkg_find_replace(\n \"NAMESPACE\",\n sprintf('useDynLib\\\\(\"?%s\"?', Package_regex),\n paste0('useDynLib(', new.Package_))\n }, \n Fast=\"ee44ef45814115003d1499284227af6f5e487ad3\",# Last commit in the PR (https://github.com/Rdatatable/data.table/pull/6679/commits) that implemented the new feature.\n Slow=\"4a2474b59637aad9e032b1eaee6e9bdcfc4df949\",# Parent of the first commit (https://github.com/Rdatatable/data.table/commit/60828522cb1dbf696ce32a7323464d9d8870b9f6) in the PR (https://github.com/Rdatatable/data.table/pull/6679/commits) that implemented the new feature.\n setup={\n set.seed(1234)\n DT <- data.table(x=runif(N),y=runif(N))\n },\n expr=data.table:::sort_by.data.table(DT, ~ x + y))\n\nit is possible to get an error like below:\n\nError in value[[3L]](cond) : \n Error in revparse_single(object, branch): Error in 'git2r_revparse_single': Requested object could not be found\n\n when trying to checkout ee44ef45814115003d1499284227af6f5e487ad3\nTiming stopped at: 0.48 1.15 4.38\n\nThis indicates that the commit can not be found in the git repo. In this case the commit is the Fast commit, in the PR which implemented the new feature. This happens because for most branches, data.table devs will click on the \"Delete branch\" button on the PR page, after merging the PR. The fix is to go to the PR page, and click the \"Restore branch\" button. If you don't know what branch it is, then you can go to the commit page, https://github.com/Rdatatable/data.table/commit/ee44ef45814115003d1499284227af6f5e487ad3 in this example, and there should be a link to the corresponding PR, as shown below.\n\nimage\n\nRelated team\n\nA team, Performance Testers is assigned to one who is actively involved with the performance testing aspects of data.table. Responsibilities that fall under this specialized role can include, but are not restricted to:\n\nEvaluating the scalability of data.table functions to track how they perform as datasets grow asymptotically.\n\nRunning comparative performance benchmarks to portray the relative efficiency of operations, i.e., in contrast to other packages that achieve similar functionality as data.table.\n\n---\n\n\\name{tables}\n\\alias{tables}\n\\title{Display 'data.table' metadata }\n\\description{\n Convenience function for concisely summarizing some metadata of all \\code{data.table}s in memory (or an optionally specified environment).\n}\n\\usage{\ntables(mb=type_size, order.col=\"NAME\", width=80,\n env=parent.frame(), silent=FALSE, index=FALSE)\n}\n\\arguments{\n \\item{mb}{ a function which accepts a \\code{data.table} and returns its size in bytes. By default, \\code{type_size} (same as \\code{TRUE}) provides a fast lower bound by excluding the size of character strings in R's global cache (which may be shared) and excluding the size of list column items (which also may be shared). A column \\code{\"MB\"} is included in the output unless \\code{FALSE} or \\code{NULL}. }\n \\item{order.col}{ Column name (\\code{character}) by which to sort the output. }\n \\item{width}{ \\code{integer}; number of characters beyond which the output for each of the columns \\code{COLS}, \\code{KEY}, and \\code{INDICES} are truncated. }\n \\item{env}{ An \\code{environment}, typically the \\code{.GlobalEnv} by default, see Details. }\n \\item{silent}{ \\code{logical}; should the output be printed? }\n \\item{index}{ \\code{logical}; if \\code{TRUE}, the column \\code{INDICES} is added to indicate the indices assorted with each object, see \\code{\\link{indices}}. }\n}\n\\details{\nUsually \\code{tables()} is executed at the prompt, where \\code{parent.frame()} returns \\code{.GlobalEnv}. \\code{tables()} may also be useful inside functions where \\code{parent.frame()} is the local scope of the function; in such a scenario, simply set it to \\code{.GlobalEnv} to get the same behaviour as at prompt.\n\n\\code{mb = utils::object.size} provides a higher and more accurate estimate of size, but may take longer. Its default \\code{units=\"b\"} is appropriate.\n\nSetting \\code{silent=TRUE} prints nothing; the metadata is returned as a \\code{data.table} invisibly whether \\code{silent} is \\code{TRUE} or \\code{FALSE}.\n}\n\\value{\n A \\code{data.table} containing the information printed.\n}\n\\seealso{ \\code{\\link{data.table}}, \\code{\\link{setkey}}, \\code{\\link{ls}}, \\code{\\link{objects}}, \\code{\\link{object.size}} }\n\\examples{\nDT = data.table(A=1:10, B=letters[1:10])\nDT2 = data.table(A=1:10000, ColB=10000:1)\nsetkey(DT,B)\ntables()\n}\n\\keyword{ data }\n\n---\n\n---\ntitle: \"Introduction to data.table\"\ndate: \"`{r} Sys.Date()`\"\noutput:\n litedown::html_format\nvignette: >\n %\\VignetteIndexEntry{Introduction to data.table}\n %\\VignetteEngine{litedown::vignette}\n \\usepackage[utf8]{inputenc}\n---\n\n```{r, echo=FALSE, file='_translation_links.R'}\n```\n`{r} .write.translation.links(\"Translations of this document are available in: %s\")`\n\n```{r, echo = FALSE, message = FALSE}\nlibrary(data.table)\nlitedown::reactor(comment = \"# \")\n.old.th = setDTthreads(1)\n```\n\nThis vignette introduces the `data.table` syntax, its general form, how to *subset* rows, *select and compute* on columns, and perform aggregations *by group*. Familiarity with the `data.frame` data structure from base R is useful, but not essential to follow this vignette.\n\n***\n\n## Data analysis using `data.table`\n\nData manipulation operations such as *subset*, *group*, *update*, *join*, etc. are all inherently related. Keeping these *related operations together* allows for:\n\n* *concise* and *consistent* syntax irrespective of the set of operations you would like to perform to achieve your end goal.\n\n* performing analysis *fluidly* without the cognitive burden of having to map each operation to a particular function from a potentially huge set of functions available before performing the analysis.\n\n* *automatically* optimising operations internally and very effectively by knowing precisely the data required for each operation, leading to very fast and memory-efficient code.\n\nBriefly, if you are interested in reducing *programming* and *compute* time tremendously, then this package is for you. The philosophy that `data.table` adheres to makes this possible. Our goal is to illustrate it through this series of vignettes.\n\n## Data {#data}\n\nIn this vignette, we will use [NYC-flights14](https://raw.githubusercontent.com/Rdatatable/data.table/master/vignettes/flights14.csv) data obtained from the [flights](https://github.com/arunsrinivasan/flights) package (available on GitHub only). It contains On-Time flights data from the Bureau of Transportation Statistics for all the flights that departed from New York City airports in 2014 (inspired by [nycflights13](https://github.com/tidyverse/nycflights13)). The data is available only for Jan-Oct'14.\n\nWe can use `data.table`'s fast-and-friendly file reader `fread` to load `flights` directly as follows:\n\n```{r, echo = FALSE}\noptions(width = 100L)\n```\n\n```{r}\ninput <- if (file.exists(\"flights14.csv\")) {\n \"flights14.csv\"\n} else {\n \"https://raw.githubusercontent.com/Rdatatable/data.table/master/vignettes/flights14.csv\"\n}\nflights <- fread(input)\nflights\ndim(flights)\n```\n\nAside: `fread` accepts `http` and `https` URLs directly, as well as operating system commands such as `sed` and `awk` output. See `?fread` for examples.\n\n## Introduction\n\nIn this vignette, we will\n\n1. Start with the basics - what is a `data.table`, its general form, how to *subset* rows, how to *select and compute* on columns;\n\n2. Then we will look at performing data aggregations by group\n\n## 1. Basics {#basics-1}\n\n### a) What is `data.table`? {#what-is-datatable-1a}\n\n`data.table` is an R package that provides **an enhanced version** of a `data.frame`, the standard data structure for storing data in `base` R. In the [Data](#data) section above, we saw how to create a `data.table` using `fread()`, but alternatively we can also create one using the `data.table()` function. Here is an example:\n\n```{r}\nDT = data.table(\n ID = c(\"b\",\"b\",\"b\",\"a\",\"a\",\"c\"),\n a = 1:6,\n b = 7:12,\n c = 13:18\n)\nDT\nclass(DT$ID)\n```\n\nYou can also convert existing objects to a `data.table` using `setDT()` (for `data.frame` and `list` structures) or `as.data.table()` (for other structures). For more details pertaining to the difference (goes beyond the scope of this vignette), please see `?setDT` and `?as.data.table`.\n\n#### Note that:\n\n* Row numbers are printed with a `:` in order to visually separate the row number from the first column.\n\n---\n\nback to data.table after a long time with dplyr #rstats\n\n25 Dec 2014 Hadley Wickham on Hacker News\n\nData tables are extremely fast but I think their concision makes it harder to learn and code that uses it is harder to read after you've written it. It's very reminiscent of APL.\n\nOur response: See the hacker news item and comparing dplyr to data.table on Stack Overflow. The word reminiscent was used to convey the notion of-the-past and is meant as criticism. Note that Hadley was responding to a positive post about data.table on Hacker News. The original item was :\n\nAnyone doing R comparisons should use data.table instead of data.frame. More so for benchmarks. data.table is the best data structure/query language I have found in my career. It's leading the way in The R world, and in my way, in all the data-focused languages.\n\nHadley sought to shoot down this positive sentiment. His negative sentiment is what has stuck in the community rather than the original post which was positive. That's what works.\n\n26 Jun 2014 Hadley Wickham on Stack Overflow\n\nAlso read.csv() reads everything into a big character matrix and then modifies that, does fread() do the same thing? In fastread we guess column types and then coerce as we go to avoid a complete copy of the df.\n\nThe Stack Overflow question is \"Reason behind speed of fread in data.table package in R\" and an implicit compliment to data.table. That's the context. The comment is a subtle way to i) create doubt about fread and ii) announce his new fastread package which had not been known before that. fastread subsequently became readr.\n\n---\n\nSegún los resultados de `R CMD check`, asegúrese de que se importen todas las funciones utilizadas, los símbolos especiales, los genéricos S3 y las clases S4 de `data.table`.\n\nEsto implica agregar directivas `importFrom(data.table, ...)` para símbolos, funciones y genéricos de S3, o directivas `importClassesFrom(data.table, ...)` para clases de S4, según corresponda. Consulte \"Escritura de extensiones de R\" para obtener más información sobre cómo hacerlo correctamente.\n\n#### Importación completa\n\nComo alternativa, puede importar todas las funciones de `data.table` a la vez, aunque esto generalmente no se recomienda:\n\n```r\nimport(data.table)\n```\n\n**Justificación para evitar importaciones generales:** \n1. **Documentación**: El archivo NAMESPACE puede servir como buena documentación de cómo depende de ciertos paquetes.\n2. **Evitar conflictos**: Las importaciones generales pueden causar fallos sutiles. Por ejemplo, si importa `import(pkgA)` e `import(pkgB)`, pero posteriormente pkgB exporta una función también exportada por pkgA, esto romperá su paquete debido a conflictos en su espacio de nombres, lo cual no está permitido por `R CMD check` y CRAN.\n\n### Paso 3: Actualice sus archivos de código R fuera del directorio R/ del paquete\n\nAl mover un paquete de \"Depends\" a \"Imports\", ya no se adjuntará automáticamente al cargarlo. Esto puede ser importante para ejemplos, pruebas, viñetas y demostraciones, donde los paquetes de \"Imports\" deben adjuntarse explícitamente.\n\n**Antes (con `Depends`):**\n\n```r\n# data.table functions are directly available\nlibrary(MyPkgDependsDataTable)\ndt <- data.table(x = 1:10, y = letters[1:10])\nsetDT(dt)\nresult <- merge(dt, other_dt, by = \"x\")\n```\n\n**Después (con `Imports`):**\n\n```r\n# Explicitly load data.table in user scripts or vignettes\nlibrary(data.table)\nlibrary(MyPkgDependsDataTable)\ndt <- data.table(x = 1:10, y = letters[1:10])\nsetDT(dt)\nresult <- merge(dt, other_dt, by = \"x\")\n```\n\n### Beneficios de usar `Imports`\n\n- **Facilidad de uso**: `Depends` modifica la ruta `search()` de los usuarios, posiblemente sin su consentimiento.\n- **Gestión del espacio de nombres**: Solo están disponibles las funciones que tu paquete importa explícitamente, lo que reduce el riesgo de conflictos de nombres de funciones.\n- **Carga de paquetes más limpia**: Las dependencias de tu paquete no se vinculan a la ruta de búsqueda, lo que hace que el proceso de carga sea más limpio y potencialmente más rápido.\n- **Mantenimiento más sencillo**: Simplifica las tareas de mantenimiento a medida que evolucionan las API de las dependencias ascendentes. Depender demasiado de `Depends` puede generar conflictos y problemas de compatibilidad con el tiempo.\n\n```{r, echo = FALSE, message = FALSE}\ndata.table::setDTthreads(.old.th)\n```\n\n---\n\n#: onAttach.R:26\n#, c-format\nmsgid \"Latest news: r-datatable.com\"\nmsgstr \"Últimas notícias: r-datatable.com\"\n\n#: onAttach.R:27\nmsgid \"TRANSLATION CHECK\"\nmsgstr \"VERIFICAÇÃO DE TRADUÇÃO\"\n\n#: onAttach.R:29\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"Running data.table in English; package support is available in English only. \"\n\"When searching for online help, be sure to also check for the English error \"\n\"message. This can be obtained by looking at the po/R-.po and po/\"\n\".po files in the package source, where the native language and \"\n\"English error messages can be found side-by-side.%s\\n\"\n\"**********\"\nmsgstr \"\"\n\"**********\\n\"\n\"Executando data.table em português; o suporte ao pacote está disponível \"\n\"apenas em inglês. Ao procurar ajuda online, certifique-se de verificar \"\n\"também a mensagem de erro em inglês. Isso pode ser obtido examinando os \"\n\"arquivos po/R-pt_BR.po e po/pt_BR.po no código-fonte do pacote, onde as \"\n\"mensagens de erro no idioma nativo e em inglês podem ser encontradas lado a \"\n\"lado.%s\\n\"\n\"**********\"\n\n#: onAttach.R:30\nmsgid \"\"\n\"You can also try calling Sys.setLanguage('en') prior to reproducing the \"\n\"error message.\"\nmsgstr \"\"\n\"Você também pode tentar chamar Sys.setLanguage('en') antes de reproduzir a \"\n\"mensagem de erro.\"\n\n#: onAttach.R:34\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"This development version of data.table was built more than 4 weeks ago. \"\n\"Please update: data.table::update_dev_pkg()\\n\"\n\"**********\"\nmsgstr \"\"\n\"**********\\n\"\n\"Esta versão de desenvolvimento do data.table foi construída há mais de 4 \"\n\"semanas. Por favor, atualize: data.table::update_dev_pkg()\\n\"\n\"**********\"\n\n#: onAttach.R:36\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"This installation of data.table has not detected OpenMP support. It should \"\n\"still work but in single-threaded mode.\"\nmsgstr \"\"\n\"**********\\n\"\n\"Esta instalação do data.table não detectou suporte ao OpenMP. Ainda deve \"\n\"funcionar, mas em modo de single-threaded.\"\n\n#: onAttach.R:38\n#, c-format\nmsgid \"\"\n\"This is a Mac. Please read https://mac.r-project.org/openmp/. Please engage \"\n\"with Apple and ask them for support. Check r-datatable.com for updates, and \"\n\"our Mac instructions here: https://github.com/Rdatatable/data.table/wiki/\"\n\"Installation. After several years of many reports of installation problems \"\n\"on Mac, it's time to gingerly point out that there have been no similar \"\n\"problems on Windows or Linux.\\n\"\n\"**********\"\nmsgstr \"\"\n\"Este é um Mac. Por favor, leia https://mac.r-project.org/openmp/. Por favor, \"\n\"envolva-se com a Apple e peça suporte. Verifique r-datatable.com para \"\n\"atualizações e nossas instruções para Mac aqui: https://github.com/\"\n\"Rdatatable/data.table/wiki/Installation. Após vários anos de muitos relatos \"\n\"de problemas de instalação no Mac, é hora de apontar cuidadosamente que não \"\n\"houve problemas semelhantes no Windows ou Linux.\\n\"\n\"**********\"\n\n#: onAttach.R:40\n#, c-format\nmsgid \"\"\n\"This is %s. This warning should not normally occur on Windows or Linux where \"\n\"OpenMP is turned on by data.table's configure script by passing -fopenmp to \"\n\"the compiler. If you see this warning on Windows or Linux, please file a \"\n\"GitHub issue.\\n\"\n\"**********\"\nmsgstr \"\"\n\"Este é %s. Este aviso normalmente não deve ocorrer no Windows ou Linux, onde \"\n\"o OpenMP é ativado pelo script de configuração do data.table passando \"\n\"-fopenmp para o compilador. Se você vir este aviso no Windows ou Linux, por \"\n\"favor, relate no rastreador de problemas no GitHub.\\n\"\n\"**********\"\n\n#: onLoad.R:5\n#, c-format\nmsgid \"\"\n\"Option 'datatable.nomatch' is defined but is now ignored. Please see note 11 \"\n\"in v1.12.4 NEWS (Oct 2019), and note 14 in v1.14.2.\"\nmsgstr \"\"\n\"Opção 'datatable.nomatch' está definida, mas agora é ignorada. Por favor, \"\n\"veja a nota 11 nas notícias de v1.12.4 (Outubro de 2019) e a nota 14 em \"\n\"v1.14.2.\"\n\n---\n\n![Grouping, Illustrated](plots/grouping_illustration.png)\n\n\nIn the case of grouping, `.SD` is multiple in nature -- it refers to _each_ of these sub-`data.table`s, _one-at-a-time_ (slightly more accurately, the scope of `.SD` is a single sub-`data.table`). This allows us to concisely express an operation that we'd like to perform on _each sub-`data.table`_ before the re-assembled result is returned to us.\n\nThis is useful in a variety of settings, the most common of which are presented here:\n\n## Group Subsetting\n\nLet's get the most recent season of data for each team in the Lahman data. This can be done quite simply with:\n\n```{r group_sd_last}\n# the data is already sorted by year; if it weren't\n# we could do Teams[order(yearID), .SD[.N], by = teamID]\nTeams[ , .SD[.N], by = teamID]\n```\n\nRecall that `.SD` is itself a `data.table`, and that `.N` refers to the total number of rows in a group (it's equal to `nrow(.SD)` within each group), so `.SD[.N]` returns the _entirety of `.SD`_ for the final row associated with each `teamID`.\n\nAnother common version of this is to use `.SD[1L]` instead to get the _first_ observation for each group, or `.SD[sample(.N, 1L)]` to return a _random_ row for each group.\n\n## Group Optima\n\nSuppose we wanted to return the _best_ year for each team, as measured by their total number of runs scored (`R`; we could easily adjust this to refer to other metrics, of course). Instead of taking a _fixed_ element from each sub-`data.table`, we now define the desired index _dynamically_ as follows:\n\n```{r sd_team_best_year}\nTeams[ , .SD[which.max(R)], by = teamID]\n```\n\nNote that this approach can of course be combined with `.SDcols` to return only portions of the `data.table` for each `.SD` (with the caveat that `.SDcols` should be fixed across the various subsets).\n\n_NB_: `.SD[1L]` is currently optimized by [_`GForce`_](https://Rdatatable.gitlab.io/data.table/library/data.table/html/datatable-optimize.html) ([see also](https://stackoverflow.com/questions/22137591/about-gforce-in-data-table-1-9-2)), `data.table` internals which massively speed up the most common grouped operations like `sum` or `mean` -- see `?GForce` for more details and keep an eye on/voice support for feature improvement requests for updates on this front: [1](https://github.com/Rdatatable/data.table/issues/735), [2](https://github.com/Rdatatable/data.table/issues/2778), [3](https://github.com/Rdatatable/data.table/issues/523), [4](https://github.com/Rdatatable/data.table/issues/971), [5](https://github.com/Rdatatable/data.table/issues/1197), [6](https://github.com/Rdatatable/data.table/issues/1414).\n\n## Grouped Regression\n\nReturning to the inquiry above regarding the relationship between `ERA` and `W`, suppose we expect this relationship to differ by team (i.e., there's a different slope for each team). We can easily re-run this regression to explore the heterogeneity in this relationship as follows (noting that the standard errors from this approach are generally incorrect -- the specification `ERA ~ W*teamID` will be better -- this approach is easier to read and the _coefficients_ are OK):\n\n---\n\nAinsi, data.table peut hériter de `data.frame` sans utiliser `...`. Si nous utilisions `...`, les noms d'arguments invalides ne seraient pas détectés.\n\nL'argument `drop` n'est jamais utilisé par `[.data.table`. C'est un substitut pour les packages non compatibles avec data.table lorsqu'ils utilisent la syntaxe `[.data.frame` directement sur un data.table.\n\n## Les jonctions par roulement sont cool et très rapides ! C'était difficile à programmer ?\n\nLa ligne dominante sur ou avant la ligne `i` est la ligne finale que la recherche binaire teste de toute façon. Donc `roll = TRUE` est essentiellement un interrupteur dans le code C de la recherche binaire pour retourner cette ligne.\n\n## Pourquoi `DT[i, col := valeur]` retourne-t-il la totalité de `DT` ? Je m'attendais à ce qu'il n'y ait pas de valeur visible (ce qui est cohérent avec `<-`), ou à ce qu'il y ait un message ou une valeur de retour contenant le nombre de lignes mises à jour. Il n'est pas évident que les données aient été mises à jour par référence.\n\nCeci a été modifié dans la version 1.8.3 pour répondre à vos attentes. Veuillez mettre à jour.\n\nL'ensemble de `DT` est retourné (maintenant de manière invisible) pour que la syntaxe composée puisse fonctionner ; *e.g.*, `DT[i, done := TRUE][ , sum(done)]`. Le nombre de lignes mises à jour est retourné quand `verbose` est `TRUE`, soit sur une base par requête, soit globalement en utilisant `options(datatable.verbose = TRUE)`.\n\n## D'accord, merci. Qu'y a-t-il de si difficile dans le fait que le résultat de `DT[i, col := value]` soit renvoyé de façon invisible ?\n\nR force en interne la visibilité pour `[`. La valeur de la colonne eval de FunTab (voir [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) pour `[` est `0` ce qui signifie \"force `R_Visible` on\" (voir [R-Internals section 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting) ). Par conséquent, lorsque nous avons essayé `invisible()` ou de mettre `R_Visible` à `0` directement nous-mêmes, `eval` dans [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) l'a forcé à nouveau.\n\nPour résoudre ce problème, la clé était de ne plus essayer d'arrêter l'exécution de la méthode print après un `:=`. Au lieu de cela, à l'intérieur de `:=` nous mettons maintenant (à partir de la version 1.8.3) un drapeau global que la méthode print utilise pour savoir si elle doit imprimer ou non.\n\n## Pourquoi dois-je taper `DT` parfois deux fois après avoir utilisé `:=` pour imprimer le résultat dans la console ?\n\nC'est un inconvénient malheureux pour faire fonctionner [#869](https://github.com/Rdatatable/data.table/issues/869). Si un `:=` est utilisé à l'intérieur d'une fonction sans `DT[]` avant la fin de la fonction, alors la prochaine fois que `DT` est tapé à l'invite, rien ne sera affiché. Un `DT` répété sera affiché. Pour éviter cela : incluez un `DT[]` après le dernier `:=` dans votre fonction. Si ce n'est pas possible (par exemple, ce n'est pas une fonction que vous pouvez changer), alors `print(DT)` et `DT[]` à l'invite sont garantis de s’afficher. Comme précédemment, l'ajout d'un `[]` supplémentaire à la fin de la requête `:=` est un idiome recommandé pour mettre à jour et ensuite imprimer ; e.g.> `DT[,foo:=3L][]`.\n\n## J'ai remarqué que `base::cbind.data.frame` (et `base::rbind.data.frame`) semble être modifié par data.table. Comment cela est-il possible ? Pourquoi ?\n\n---\n\nHTML vignettes\n\nIntroduction to data.table\n\nReference semantics\n\nKeys and fast binary search based subsets\n\nSecondary indices and auto indexing\n\nEfficient reshaping using data.tables\n\nFrequently asked questions\n\nDocumentation and examples\n\n?data.table\n\n?fread\n\npdf manual\n\ndevel html manual\n\ncheat sheet\n\nin-depth tables tutorial\n\nQuestions & Answers\n\ncommunity support on data.table stackoverflow tag\n\nRead [[Support]] wiki on how to properly ask questions and additional information about support.\n\nNotices/discussion\n\nFollow #rdatatable\n\nClick the 'watch' button at the top and right of this page (next to star and fork)\n\nUser reviews\n\nCrantastic\n\nLearn by doing\n\ndata.table course on DataCamp\n\n---\n\n2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk\n\n2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse\n\n2019.07 : Bayesian analysis with Stan & Data manipulation with data.table, Jared Kai Swan, Los Angeles East\n\n2019.07 : Start using data.table, Megan Stodel, Ministry of Justice Coffee and Coding\n\n2019.07 : Wrangling 4.6M rows of Financial Data (Home Loans Time Series) in R with data.table, Matt Dancho, Business Science Learning Lab\n\n2019.07 : data.table: a slide deck of data.table piping Gina Reynolds, slides\n\n2019.06 : why data.table?, Jan Gorecki, Poznan R User Group\n\n2019.05 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O Meetup Mountain View\n\n2019.05 : Workshop: Getting Started in R and data.table - Saghir Bashir, ilustat.com\n\n2019.04 : Pipes or Brackets: dplyr and data.table, Jeremy Guinta & Amy Linehan, satRday LA\n\n2019.02 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O World San Francisco\n\n2019.01 : Introduction to Automatic and Scalable Machine Learning with H2O and R (afternoon session data.table), Dmytro Perepolkin and Raoul Wolf, University of Oslo Library\n\n2018.12 : Workshop: Getting Started in R and data.table, Saghir Bashir, Data Science Unplugged Lisbon\n\n2018.10 : data.table for R, Python and updated-daily benchmarks, Matt Dowle, H2OWorld London\n\n2018.09 : Life in the Fast Lane: data.table Intro and Best Practices, Bill Gold, New York OSPM\n\n2018.09 : ALTREP from a data.table perspective, Matt Dowle, DSC Stanford I talked ad-lib and showed code on screen; no slides.\n\n2018.09 : Tutorial: efficient data manipulation with data.table, Jaap Walhout, uRos The Hague\n\n2018.08 : Success with OpenMP in R package data.table, Matt Dowle, JSM Vancouver\n\n2018.07 : 12 years of data.table (past, present and future), Arun Srinivasan, R in Montreal\n\n2018.07 : What's new in data.table, Jan Gorecki, WhyR Wroclaw\n\n2018.06 : Data munging in driverless.ai with datatable, Pasha Stetsenko, H2OWorld New York\n\n2018.05 : Top 10 reasons to use data.table; O Jossome, T Robert and F Meyer, dreamRs 2018\n\n2018.05 : The beauty of data manipulation with data.table, János Divényi, eRum Budapest\n\n2017.12 : data.table, Matt Dowle, H2O World Mountain View\n\n2017.11 : data.table, Sebastian Jeworutzki, useR! Bochum\n\n2017.07 : data.table for beginners (tutorial), Arun Srinivasan, useR! Brussels\n\n2017.04 : Parallel fread and other news from data.table, Matt Dowle, Bay Area RUG\n\n2017.04 : data.table power hour, Steph Locke, SQLBits London\n\n2017.01 : New developments in the data.table package, Arun Srinivasan, AmstRdam RUG\n\n2016.09 : Data manipulation the #rdatatable way, Arun Srinivasan, SatRdays Budapest\n\n2016.07 : Parallel and distributed ordered join benchmark, Matt Dowle, H2O Open Tour New York\n\n2016.07 : Proposal for parallel sort in base R (and Python/Julia), Matt Dowle, DSC Stanford\n\n2016.06 : Efficient in-memory non-equi joins, Arun Srinivasan, useR! Stanford\n\n2016.06 : Ninja Moves with data.table 3hr tutorial, Matt Dowle & Arun Srinivasan, useR! Stanford\n\n2016.05 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin\n\n2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, Data by the Bay San Francisco\n\n2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, H2O Open Tour Chicago\n\n2016.05 : R Lecture #3: data.table, Peter Hurford\n\n2016.02 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin\n\n2016.02 Parallel and Distributed Joining, Matt Dowle, Bay Area R User Group\n\n2016.01 Invited lecture by Matt Dowle at Stat290 Paradigms for Computing with Data, Stanford\n\n2016.01 Invited lecture by Matt Dowle at FNCE3490 Data Science and Business Analytics, Santa Clara University\n\n2016.01 data table discussion, Gaurav Chaturedi & Nicholas Ng, Singapore R User Group\n\n---\n\n15. `mult=\"all\"` -vs- `mult=\"first\"|\"last\"` now return consistent types and columns, [#340](https://github.com/Rdatatable/data.table/issues/340). Thanks to Michele Carriero for highlighting.\n\n 16. `duplicated.data.table` and `unique.data.table` gains `fromLast = TRUE/FALSE` argument, similar to base. Default value is FALSE. Closes [#347](https://github.com/Rdatatable/data.table/issues/347).\n\n 17. `anyDuplicated.data.table` is now implemented. Closes [#350](https://github.com/Rdatatable/data.table/issues/350). Thanks to M C (bluemagister) for reporting.\n\n 18. Complex j-expressions of the form `DT[, c(..., lapply(.SD, fun)), by=grp]`are now optimised as long as `.SD` is of the form `lapply(.SD, fun)` or `.SD`, `.SD[1]` or `.SD[1L]`. This resolves [#370](https://github.com/Rdatatable/data.table/issues/370). Thanks to Sam Steingold for reporting.\n This also completes the first two task lists in [#735](https://github.com/Rdatatable/data.table/issues/735).\n ```R\n ## example:\n DT[, c(.I, lapply(.SD, sum), mean(x), lapply(.SD, log)), by=grp]\n ## is optimised to\n DT[, list(.I, x=sum(x), y=sum(y), ..., mean(x), log(x), log(y), ...), by=grp]\n ## and now... these variations are also optimised internally for speed\n DT[, c(..., .SD, lapply(.SD, sum), ...), by=grp]\n DT[, c(..., .SD[1], lapply(.SD, sum), ...), by=grp]\n DT[, .SD, by=grp]\n DT[, c(.SD), by=grp]\n DT[, .SD[1], by=grp] # Note: but not yet DT[, .SD[1,], by=grp]\n DT[, c(.SD[1]), by=grp]\n DT[, head(.SD, 1), by=grp] # Note: but not yet DT[, head(.SD, -1), by=grp]\n # but not yet optimised\n DT[, c(.SD[a], .SD[x>1], lapply(.SD, sum)), by=grp] # where 'a' is, say, a numeric or a data.table, and also for expressions like x>1\n ```\n The underlying message is that `.SD` is being slowly optimised internally wherever possible, for speed, without compromising in the nice readable syntax it provides.\n\n 19. `setDT` gains `keep.rownames = TRUE/FALSE` argument, which works only on `data.frame`s. TRUE retains the data.frame's row names as a new column named `rn`.\n\n 20. The output of `tables()` now includes `NCOL`. Thanks to @dnlbrky for the suggestion.\n\n 21. `DT[, LHS := RHS]` (or its equivalent in `set`) now provides a warning and returns `DT` as it was, instead of an error, when `length(LHS) = 0L`, [#343](https://github.com/Rdatatable/data.table/issues/343). For example:\n ```R\n DT[, grep(\"^b\", names(DT)) := NULL] # where no columns start with b\n # warns now and returns DT instead of error\n ```\n\n 22. GForce now is also optimised for j-expression with `.N`. Closes [#334](https://github.com/Rdatatable/data.table/issues/334) and part of [#523](https://github.com/Rdatatable/data.table/issues/523).\n ```R\n DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.2 - doesn't know to use GForce - will be (relatively) slower\n DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.3+ - will use GForce.\n ```\n\n 23. `setDF` is now implemented. It accepts a data.table and converts it to data.frame by reference, [#338](https://github.com/Rdatatable/data.table/issues/338). Thanks to canneff for the discussion on data.table mailing list.\n\n 24. `.I` gets named as `I` (instead of `.I`) wherever possible, similar to `.N`, [#344](https://github.com/Rdatatable/data.table/issues/344).\n\n 25. `setkey` on `.SD` is now an error, rather than warnings for each group about rebuilding the key. The new error is similar to when attempting to use `:=` in a `.SD` subquery: `\".SD is locked. Using set*() functions on .SD is reserved for possible future use; a tortuously flexible way to modify the original data by group.\"` Thanks to Ron Hylton for highlighting the issue on datatable-help.\n\n 26. Looping calls to `unique(DT)` such as in `DT[,unique(.SD),by=group]` is now faster by avoiding internal overhead of calling `[.data.table`. Thanks again to Ron Hylton for highlighting on datatable-help. His example is reduced from 28 sec to 9 sec, with identical results.\n\n---\n\n# NB: methods _has_ to be attached before data.table in order for methods::as() to\n# find the right dispatch when trying as(x, \"IDate\"). This might be an R bug, but\n# even running library(methods, pos=\"package:base\") after attaching data.table doesn't work.\nlibrary(methods)\nlibrary(data.table)\ntest.data.table(script=\"S4.Rraw\")\n\n---\n\nYou may also want to use just a subset of `data.table` functions; for example, some packages may simply make use of `data.table`'s high-performance CSV reader and writer, for which you can add `importFrom(data.table, fread, fwrite)` in your `NAMESPACE` file. It is also possible to import all functions from a package _excluding_ particular ones using `import(data.table, except=c(fread, fwrite))`.\n\nBe sure to read also the note about non-standard evaluation in `data.table` in [the section on \"undefined globals\"](#globals).\n\n## Usage\n\nAs an example we will define two functions in `a.pkg` package that uses `data.table`. One function, `gen`, will generate a simple `data.table`; another, `aggr`, will do a simple aggregation of it.\n\n```r\ngen = function (n = 100L) {\n dt = as.data.table(list(id = seq_len(n)))\n dt[, grp := ((id - 1) %% 26) + 1\n ][, grp := letters[grp]\n ][]\n}\naggr = function (x) {\n stopifnot(\n is.data.table(x),\n \"grp\" %in% names(x)\n )\n x[, .N, by = grp]\n}\n```\n\n## Testing\n\nBe sure to include tests in your package. Before each major release of `data.table`, we check reverse dependencies. This means that if any changes in `data.table` would break your code, we will be able to spot breaking changes and inform you before releasing the new version. This of course assumes you will publish your package to CRAN or Bioconductor. The most basic test can be a plaintext R script in your package directory `tests/test.R`:\n\n```r\nlibrary(a.pkg)\ndt = gen()\nstopifnot(nrow(dt) == 100)\ndt2 = aggr(dt)\nstopifnot(nrow(dt2) < 100)\n```\n\nWhen testing your package, you may want to use `R CMD check --no-stop-on-test-error`, which will continue after an error and run all your tests (as opposed to stopping on the first line of script that failed).\n\n## Testing using `testthat`\n\nIt is very common to use the `testthat` package for purpose of tests. Testing a package that imports `data.table` is no different from testing other packages. An example test script `tests/testthat/test-pkg.R`:\n\n```r\ncontext(\"pkg tests\")\n\ntest_that(\"generate dt\", { expect_true(nrow(gen()) == 100) })\ntest_that(\"aggregate dt\", { expect_true(nrow(aggr(gen())) < 100) })\n```\n\nIf `data.table` is in Suggests (but not Imports) then you need to declare `.datatable.aware=TRUE` in one of the R/* files to avoid \"object not found\" errors when testing via `testthat::test_package` or `testthat::test_check`.\n\n## Dealing with \"undefined global functions or variables\" {#globals}\n\n`data.table`'s use of R's deferred evaluation (especially on the left-hand side of `:=`) is not well-recognised by `R CMD check`. This results in `NOTE`s like the following during package check:\n\n```\n* checking R code for possible problems ... NOTE\naggr: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'id'\nUndefined global functions or variables:\ngrp id\n```\n\nThe easiest way to deal with this is to pre-define those variables within your package and set them to `NULL`, optionally adding a comment (as is done in the refined version of `gen` below). When possible, you could also use a character vector instead of symbols (as in `aggr` below):\n\n```r\ngen = function (n = 100L) {\n id = grp = NULL # due to NSE notes in R CMD check\n dt = as.data.table(list(id = seq_len(n)))\n dt[, grp := ((id - 1) %% 26) + 1\n ][, grp := letters[grp]\n ][]\n}\naggr = function (x) {\n stopifnot(\n is.data.table(x),\n \"grp\" %in% names(x)\n )\n x[, .N, by = \"grp\"]\n}\n```\n\n---\n\n#: onAttach.R:26\n#, c-format\nmsgid \"Latest news: r-datatable.com\"\nmsgstr \"Últimas novedades: r-datatable.com\"\n\n#: onAttach.R:27\nmsgid \"TRANSLATION CHECK\"\nmsgstr \"VERIFICACIÓN DE TRADUCCIÓN\"\n\n#: onAttach.R:29\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"Running data.table in English; package support is available in English only. \"\n\"When searching for online help, be sure to also check for the English error \"\n\"message. This can be obtained by looking at the po/R-.po and po/\"\n\".po files in the package source, where the native language and \"\n\"English error messages can be found side-by-side.%s\\n\"\n\"**********\"\nmsgstr \"\"\n\"**********\\n\"\n\"Ejecutando data.table en Español. El soporte del paquete está disponible \"\n\"solo en inglés. Cuando busque ayuda en línea, asegúrese de comprobar también \"\n\"el mensaje de error en inglés, examinando los archivos po/R-.po y po/\"\n\".po en el código fuente del paquete. Allí se encuentran los mensajes \"\n\"de error en el idioma nativo y en inglés uno al lado del otro.%s\\n\"\n\"**********\"\n\n#: onAttach.R:30\nmsgid \"\"\n\"You can also try calling Sys.setLanguage('en') prior to reproducing the \"\n\"error message.\"\nmsgstr \"\"\n\"Puede intentar llamar Sys.setLanguage('en') antes de reproducir el mensaje \"\n\"de error.\"\n\n#: onAttach.R:34\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"This development version of data.table was built more than 4 weeks ago. \"\n\"Please update: data.table::update_dev_pkg()\\n\"\n\"**********\"\nmsgstr \"\"\n\"**********\\n\"\n\"Esta versión de desarrollo de data.table se creó hace más de 4 semanas. \"\n\"Actualice: data.table::update_dev_pkg()\\n\"\n\"**********\"\n\n#: onAttach.R:36\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"This installation of data.table has not detected OpenMP support. It should \"\n\"still work but in single-threaded mode.\"\nmsgstr \"\"\n\"************\\n\"\n\"Esta instalación de data.table no ha detectado compatibilidad con OpenMP. \"\n\"Aún debería funcionar pero en modo de un solo hilo.\"\n\n#: onAttach.R:38\n#, c-format\nmsgid \"\"\n\"This is a Mac. Please read https://mac.r-project.org/openmp/. Please engage \"\n\"with Apple and ask them for support. Check r-datatable.com for updates, and \"\n\"our Mac instructions here: https://github.com/Rdatatable/data.table/wiki/\"\n\"Installation. After several years of many reports of installation problems \"\n\"on Mac, it's time to gingerly point out that there have been no similar \"\n\"problems on Windows or Linux.\\n\"\n\"**********\"\nmsgstr \"\"\n\"Esta es una Mac. Lea https://mac.r-project.org/openmp/. Comuníquese con \"\n\"Apple y pídales ayuda. Consulte r-datatable.com para obtener actualizaciones \"\n\"y nuestras instrucciones para Mac aquí: https://github.com/Rdatatable/data.\"\n\"table/wiki/Installation. Después de varios años de muchos informes de \"\n\"problemas de instalación en Mac, es hora de señalar con cautela que no ha \"\n\"habido problemas similares en Windows o Linux.\\n\"\n\"**********\"\n\n#: onAttach.R:40\n#, c-format\nmsgid \"\"\n\"This is %s. This warning should not normally occur on Windows or Linux where \"\n\"OpenMP is turned on by data.table's configure script by passing -fopenmp to \"\n\"the compiler. If you see this warning on Windows or Linux, please file a \"\n\"GitHub issue.\\n\"\n\"**********\"\nmsgstr \"\"\n\"Esto es %s. Esta advertencia normalmente no debería aparecer en Windows o \"\n\"Linux donde OpenMP se activa mediante el script de configuración de data.\"\n\"table pasando -fopenmp al compilador. Si ve esta advertencia en Windows o \"\n\"Linux, presente un problema en GitHub.\\n\"\n\"**********\"\n\n#: onLoad.R:5\n#, c-format\nmsgid \"\"\n\"Option 'datatable.nomatch' is defined but is now ignored. Please see note 11 \"\n\"in v1.12.4 NEWS (Oct 2019), and note 14 in v1.14.2.\"\nmsgstr \"\"\n\"La opción 'datatable.nomatch' está definida pero ahora se ignora. Consulte \"\n\"la nota 11 en v1.12.4 NEWS (octubre de 2019) y la nota 14 en v1.14.2.\"\n\n---\n\nRunning comparative performance benchmarks to portray the relative efficiency of operations, i.e., in contrast to other packages that achieve similar functionality as data.table.\n\nWriting open-source material like blog posts to document such (with code to run the benchmarks provisioned therein), as they would tend to be a great resource for the community. Examples: df-atime-figures, df-partial-match\n\nDesigning test scenarios to measure performance, such as handling large datasets, performing complex queries, having concurrent operations, etc.\n\nStaying informed with the latest developments in R programming and performance testing methodologies to bring such updates to data.table.\n\n---\n\nselfrefok = function(DT,verbose=getOption(\"datatable.verbose\")) {\n .Call(Cselfrefokwrapper,DT,verbose)\n}\n\ntruelength = function(x) .Call(Ctruelength,x)\n# deliberately no \"truelength<-\" method. setalloccol is the mechanism for that.\n# settruelength() no longer need (and so removed) now that data.table depends on R 2.14.0\n# which initializes tl to zero rather than leaving uninitialized.\n\nsetattr = function(x,name,value) {\n # Wrapper for setAttrib internal R function\n # Sets attribute by reference (no copy)\n # Named setattr (rather than setattrib) at R level to more closely resemble attr<-\n # And as from 1.7.8 is made exported in NAMESPACE for use in user attributes.\n # User can also call `attr<-` function directly, but that copies (maybe just when NAMED>0, which is always for data.frame, I think). See \"Confused by NAMED\" thread on r-devel 24 Nov 2011.\n # We tend to use setattr() internally in data.table.R because often we construct a data.table and it hasn't\n # got names yet. setnames() is the user interface which checks integrity and doesn't let you drop names for example.\n if (name==\"names\" && is.data.table(x) && length(attr(x, \"names\", exact=TRUE)) && !is.null(value))\n setnames(x,value)\n # Using setnames here so that truelength of names can be retained, to carry out integrity checks such as not\n # creating names longer than the number of columns of x, and to change the key, too\n # For convenience so that setattr(DT,\"names\",allnames) works as expected without requiring a switch to setnames.\n else {\n ans = .Call(Csetattrib, x, name, value)\n # If name==\"names\" and this is the first time names are assigned (e.g. in data.table()), this will be grown by setalloccol very shortly afterwards in the caller.\n if (!is.null(ans)) {\n warningf(\"Input is a length=1 logical that points to the same address as R's global value. Therefore the attribute has not been set by reference, rather on a copy. You will need to assign the result back to a variable. See issue #1281.\")\n x = ans\n }\n }\n # fix for #1142 - duplicated levels for factors\n if (name == \"levels\" && is.factor(x) && anyDuplicated(value))\n .Call(Csetlevels, x, (value <- as.character(value)), unique(value))\n invisible(x)\n}\n\n---\n\n3. `DT[col > val, head(.SD, 1), by = ...]` - объединяет `i` с `j` и\n `by`.\n\n#### Также не забывайте:\n\nЕсли `j` возвращает `list`, каждый элемент этого списка станет столбцом в\nрезультирующей `data.table`.\n\nВ [следующем руководстве (`vignette(\"datatable-reference-semantics\",\npackage=\"data.table\")`)](../datatable-reference-semantics.html) мы\nрассмотрим, как *добавлять/обновлять/удалять* столбцы *по ссылке* и как\nкомбинировать эти операции с `i` и `by`.\n\n***\n\n```{r, echo=FALSE}\nsetDTthreads(.old.th)\n```\n\n---\n\nRolling Joins Robert Norberg 2016.05 From a (set.)seed grows a mighty dataset Jonathan Carroll 2016.05 Feather: fast, interoperable data import/export for R David Smith 2016.05 Best packages for data manipulation in R Fisseha Berhane 2016.05 My Two favorite Packages for Data Manipulation in R Fisseha Berhane 2016.05 Use H2O and data.table to build models on large data sets in R Manish Saraswat 2016.05 The R Data I/O Shootout Eduardo Ariño de la Rubia 2016.05 Red herring bites Matt Dowle 2016.05 data.table() vs data.frame() – Learn to work on large data sets in R Manish Saraswat 2016.04 Feather: it's about metadata Wes McKinney 2016.04 Fast csv writing for R Matt Dowle 2016.04 I'll Keep Using R Michael Ekstrand 2016.04 data.table objects should not be considered data.frame instances in R [retracted] John Mount 2016.04 Learning R in Seven Simple Steps Martijn Theuwissen 2016.04 Collapsing lists of data.frames with data.table Steph Locke 2016.04 Working with databases in R Fisseha Berhane 2016.03 Data table exercises: keys and subsetting Han de Vries 2016.03 Performing SQL selects on R data frames Fisseha Berhane 2016.02 Read from hdfs with R. Brief overview of SparkR Dmitriy Selivanov 2016.02 Up to code? An algorithm is helping Chicago health officials predict restaurant safety violations (featured on TV at 06:40 ). [ Tweet ] [ Code ] PBS NewsHour 2016.01 Strategies to Speedup R Code Selva Prabhakaran 2015.12 Our R package roundup 2015 Christoph Safferling 2015.12 Who’s downloading the forecast package? Rob J Hyndman 2015.12 Solve common R problems efficiently with data.table Jan Gorecki 2015.11 Efficient aggregation (and more) using data.table David Kun 2015.11 Scaling data.table with index Jan Gorecki 2015.11 H2O World 2015 – Day 2 Highlights Anmol Rajpurohit, KDnuggets 2015.11 H2O World 2015 Joseph Rickert 2015.11 H2O.ai raises $20m series B to capitalize on rapid open source machine-learning growth Matt Aslett, 451 Research 2015.10 R and Impala: it's better to KISS than using Java Gergely Daroczi 2015.10 R: data.table – Finding the maximum row Mark Needham 2015.09 Querying a 20 million line CSV file – data.table vs data frame Mark Needham 2015.09 Data ergonomics with data.table, iHub Nairobi, with supporting materials Henk Harmsen 2015.09 R Stories from the Trenches [ Video ] [ Slides ] Szilard Pafka 2015.09 Advanced Tips and Tricks with data.table Andrew Brooks 2015.08 data.table cookbook Steph Locke 2015.07 Overlap joins in R: a speed comparison with packages sqldf and data.table Zev Ross 2015.06 Data Warehousing with R Jan Gorecki 2015.06 Auditing data transformation Jan Gorecki 2015.06 Back from R/Finance in Chicago Markus Gesmann 2015.05 Fast data munging in R Alexander Konduforov 2015.05 No THIS Is How You dplyr and data.table! Jeffrey Horner 2015.05 Comparing data frames, data.table and dplyr with random walks David Smith 2015.05 Working with \"large\" datasets, with dplyr and data.table Arthur Charpentier 2015.04 Comparing the execution time between foverlaps and findOverlaps [data.table vs GenomicRanges] Katarzyna Wręczycka 2015.04 Open Source Business Intelligence: Then and Now Steve Miller 2015.04 Mapping Flows in R with data.table and lattice Oscar Perpiñán Lamigueiro 2015.03 Need for Processing Speed: data.table OpenAnalytics 2015.03 Getting Data From An Online Source Robert Norberg 2015.02 A data.table R tutorial by DataCamp: intro to DT[i, j, by] DataCamp 2015.02 Minimal example for joining data.tables Markus Gesmann 2015.01 Using the microbenchmark package to compare the execution time of R expressions Stephen Turner 2015.01 Sessionizing Log Data Using data.table Randy Zwitch 2015.01 R in Business Intelligence Jan Gorecki 2014.12 dplyr and a very basic benchmark Szilard Pafka 2014.12 JOINing data in R using data.table Ronald Stalder 2014.12 Cheat Sheets for Data Science Steve Miller 2014.11 Partying R Style with Sqor Sports, R on Azure, and data.table Joseph Rickert 2014.11 The data.table Cheat Sheet DataCamp\n\n---\n\nrequire(data.table)\ntest.data.table(script=\"programming.Rraw\")\n\n---\n\nR Under development (unstable) (2024-12-01 r87412) -- \"Unsuffered Consequences\"\nCopyright (C) 2024 The R Foundation for Statistical Computing\nPlatform: x86_64-pc-linux-gnu\n\nR is free software and comes with ABSOLUTELY NO WARRANTY.\nYou are welcome to redistribute it under certain conditions.\nType 'license()' or 'licence()' for distribution details.\n\nR is a collaborative project with many contributors.\nType 'contributors()' for more information and\n'citation()' on how to cite R or R packages in publications.\n\nType 'demo()' for some demos, 'help()' for on-line help, or\n'help.start()' for an HTML browser interface to help.\nType 'q()' to quit R.\n\n---\n\n---\ntitle: \"Importing data.table\"\ndate: \"`{r} Sys.Date()`\"\noutput:\n litedown::html_format\nvignette: >\n %\\VignetteIndexEntry{Importing data.table}\n %\\VignetteEngine{litedown::vignette}\n \\usepackage[utf8]{inputenc}\n---\n\n```{r, echo = FALSE, message = FALSE}\nlitedown::reactor(comment = \"# \")\n.old.th = data.table::setDTthreads(1)\n```\n\n\n\n```{r, echo=FALSE, file='_translation_links.R'}\n```\n`{r} .write.translation.links(\"Translations of this document are available in: %s\")`\n\nThis document is focused on using `data.table` as a dependency in other R packages. If you are interested in using `data.table` C code from a non-R application, or in calling its C functions directly, jump to the [last section](#non-r-api) of this vignette.\n\nImporting `data.table` is no different from importing other R packages. This vignette is meant to answer the most common questions arising around that subject; the lessons presented here can be applied to other R packages.\n\n## Why to import `data.table`\n\nOne of the biggest features of `data.table` is its concise syntax which makes exploratory analysis faster and easier to write and perceive; this convenience can drive package authors to use `data.table`. Another, perhaps more important reason is high performance. When outsourcing heavy computing tasks from your package to `data.table`, you usually get top performance without needing to re-invent any of these numerical optimization tricks on your own.\n\n## Importing `data.table` is easy\n\nIt is very easy to use `data.table` as a dependency due to the fact that `data.table` does not have any of its own dependencies. This applies both to operating system and to R dependencies. It means that if you have R installed on your machine, it already has everything needed to install `data.table`. It also means that adding `data.table` as a dependency of your package will not result in a chain of other recursive dependencies to install, making it very convenient for offline installation.\n\n## `DESCRIPTION` file {#DESCRIPTION}\n\nThe first place to define a dependency in a package is the `DESCRIPTION` file. Most commonly, you will need to add `data.table` under the `Imports:` field. Doing so will necessitate an installation of `data.table` before your package can compile/install. As mentioned above, no other packages will be installed because `data.table` does not have any dependencies of its own. You can also specify the minimal required version of a dependency; for example, if your package is using the `fwrite` function, which was introduced in `data.table` in version 1.9.8, you should incorporate this as `Imports: data.table (>= 1.9.8)`. This way you can ensure that the version of `data.table` installed is 1.9.8 or later before your users will be able to install your package. Besides the `Imports:` field, you can also use `Depends: data.table` but we strongly discourage this approach (and may disallow it in future) because this loads `data.table` into your user's workspace; i.e. it enables `data.table` functionality in your user's scripts without them requesting that. `Imports:` is the proper way to use `data.table` within your package without inflicting `data.table` on your user. In fact, we hope the `Depends:` field is eventually deprecated in R since this is true for all packages.\n\n## `NAMESPACE` file {#NAMESPACE}\n\nThe next thing is to define what content of `data.table` your package is using. This needs to be done in the `NAMESPACE` file. Most commonly, package authors will want to use `import(data.table)` which will import all exported (i.e., listed in `data.table`'s own `NAMESPACE` file) functions from `data.table`.\n\n---\n\n#: data.table.R:139\n#, c-format\nmsgid \"Item '%s' not found in names of input list\"\nmsgstr \"Не могу найти «%s» среди имён входного списка\"\n\n#: data.table.R:159\n#, c-format\nmsgid \"\"\n\"[ was called on a data.table in an environment that is not data.table-aware \"\n\"(i.e. cedta()), but '%s' was used, implying the owner of this call really \"\n\"intended for data.table methods to be called. See vignette('datatable-\"\n\"importing') for details on properly importing data.table.\"\nmsgstr \"\"\n\"Метод [ был вызван для data.table из окружения, не поддерживающего data.\"\n\"table (см. ?cedta()), но было передано '%s', что означает, что вызывающей \"\n\"функции действительно нужен метод data.table. Подробнее о правильном \"\n\"использовании data.table в пакетах см. в vignette('datatable-importing').\"\n\n#: data.table.R:170\n#, c-format\nmsgid \"verbose must be logical or integer\"\nmsgstr \"«verbose» должно быть логическим или целочисленным\"\n\n#: data.table.R:171\n#, c-format\nmsgid \"verbose must be length 1 non-NA\"\nmsgstr \"«verbose» должно быть длины 1 и не-NA\"\n\n#: data.table.R:179\n#, c-format\nmsgid \"Ignoring by/keyby because 'j' is not supplied\"\nmsgstr \"Игнорирую «by»/«keyby», потому что «j» не был передан\"\n\n#: data.table.R:193\n#, c-format\nmsgid \"When by and keyby are both provided, keyby must be TRUE or FALSE\"\nmsgstr \"Когда «by» и «keyby» оба переданы, «keyby» должно быть TRUE либо FALSE\"\n\n#: data.table.R:196 data.table.R:261 data.table.R:351\nmsgid \"Argument '%s' after substitute: %s\"\nmsgstr \"Аргумент «%s» после подстановки: %s\"\n\n#: data.table.R:205\n#, c-format\nmsgid \"\"\n\"When on= is provided but not i=, on= must be a named list or data.table|\"\n\"frame, and a natural join (i.e. join on common names) is invoked. Ignoring \"\n\"on= which is '%s'.\"\nmsgstr \"\"\n\"Если указано on=, но не i=, on= должно быть именованным списком или data.\"\n\"table|frame; тогда будет выполнено натуральное соединение (т. е. по столбцам \"\n\"с общими именами). Игнорирую on=, которое имеет значение '%s'.\"\n\n#: data.table.R:218\n#, c-format\nmsgid \"\"\n\"i and j are both missing so ignoring the other arguments. This warning will \"\n\"be upgraded to error in future.\"\nmsgstr \"\"\n\"i и j отсутствуют, поэтому игнорирую остальные аргументы. В будущем это \"\n\"предупреждение будет преобразовано в ошибку.\"\n\n#: data.table.R:222\n#, c-format\nmsgid \"mult argument can only be 'first', 'last', 'all' or 'error'\"\nmsgstr \"аргумент «mult» должен быть 'first', 'last', 'all' или 'error'\"\n\n#: data.table.R:224\n#, c-format\nmsgid \"\"\n\"roll must be a single TRUE, FALSE, positive/negative integer/double \"\n\"including +Inf and -Inf or 'nearest'\"\nmsgstr \"\"\n\"roll должен быть TRUE, FALSE, положительным/отрицательным числом, включая \"\n\"+Inf и -Inf, либо 'nearest'\"\n\n#: data.table.R:226\n#, c-format\nmsgid \"roll is '%s' (type character). Only valid character value is 'nearest'.\"\nmsgstr \"\"\n\"«roll» - это '%s' (строка). Единственное допустимое строковое значение - \"\n\"'nearest'.\"\n\n#: data.table.R:231\n#, c-format\nmsgid \"rollends must be a logical vector\"\nmsgstr \"«rollends» должно быть логическим вектором\"\n\n#: data.table.R:232\n#, c-format\nmsgid \"rollends must be length 1 or 2\"\nmsgstr \"«rollends» должно быть длины 1 или 2\"\n\n#: data.table.R:240\n#, c-format\nmsgid \"\"\n\"nomatch= must be either NA or NULL (or 0 for backwards compatibility which \"\n\"is the same as NULL but please use NULL)\"\nmsgstr \"\"\n\"nomatch= должно быть либо NA, либо NULL (ранее 0 значило то же, что сейчас \"\n\"значит NULL)\"\n\n#: data.table.R:243\n#, c-format\nmsgid \"which= must be a logical vector length 1. Either FALSE, TRUE or NA.\"\nmsgstr \"which= должен быть FALSE, TRUE или NA_logical_.\"\n\n#: data.table.R:244\n#, c-format\nmsgid \"\"\n\"which==%s (meaning return row numbers) but j is also supplied. Either you \"\n\"need row numbers or the result of j, but only one type of result can be \"\n\"returned.\"\nmsgstr \"\"\n\"which==%s (значит, вернуть номера строк), но также передан j. Вы можете \"\n\"запросить либо одно, либо другое, но не всё сразу.\"\n\n---\n\n### Étape 3 : Mettre à jour vos fichiers de code R en dehors du répertoire R/ du package\n\nLorsque vous déplacez un package de `Depends` vers `Imports`, il ne sera plus automatiquement attaché lorsque votre package sera chargé. Cela peut être important pour les exemples, les tests, les vignettes et les démos, où les packages `Imports` doivent être attachés explicitement.\n\n**Avant (avec `Depends`) :**\n\n```r\n# les fonctions de data.table sont directement disponibles\nlibrary(MyPkgDependsDataTable)\ndt <- data.table(x = 1:10, y = letters[1:10])\nsetDT(dt)\nresult <- merge(dt, other_dt, by = \"x\")\n```\n\n**Après (avec `Imports`) :**\n\n```r\n# Charger explicitement data.table dans les scripts utilisateurs ou les vignettes\nlibrary(data.table)\nlibrary(MyPkgDependsDataTable)\ndt <- data.table(x = 1:10, y = letters[1:10])\nsetDT(dt)\nresult <- merge(dt, other_dt, by = \"x\")\n```\n\n### Avantages de l'utilisation de `Imports`\n\n- **Convivialité** : `Depends` modifie le chemin `search()` de vos utilisateurs, éventuellement sans qu'ils le veuillent.\n- **Gestion de l'espace de noms** : Seules les fonctions que votre package importe explicitement sont disponibles, ce qui réduit le risque de conflit de noms de fonctions.\n- **Chargement de package plus propre** : Les dépendances de votre package ne sont pas attachées au chemin de recherche, ce qui rend le processus de chargement plus propre et potentiellement plus rapide.\n- **Maintenance plus facile** : Cela simplifie les tâches de maintenance au fur et à mesure que les API des dépendances en amont évoluent. Trop dépendre de `Depends` peut conduire à des conflits et des problèmes de compatibilité au fil du temps.\n\n```{r, echo = FALSE, message = FALSE}\ndata.table::setDTthreads(.old.th)\n```\n\n---\n\n## fichier `NAMESPACE` {#NAMESPACE}\n\nLa prochaine chose à faire est de définir le contenu de `data.table` que votre package utilise. Cela doit être fait dans le fichier `NAMESPACE`. Le plus souvent, les auteurs de package voudront utiliser `import(data.table)` qui importera toutes les fonctions exportées (c'est-à-dire listées dans le fichier `NAMESPACE` de `data.table`) de `data.table`.\n\nVous pouvez aussi ne vouloir utiliser qu'un sous-ensemble des fonctions de `data.table` ; par exemple, certains packages peuvent simplement utiliser les fonctions d'écriture et lecture CSV haute performance de `data.table`, pour lesquelles vous pouvez ajouter `importFrom(data.table, fread, fwrite)` dans votre fichier `NAMESPACE`. Il est également possible d'importer toutes les fonctions d'un package *en excluant* certaines d'entre elles en utilisant `import(data.table, except=c(fread, fwrite))`.\n\nAssurez-vous de lire également la note sur l'évaluation non standard dans `data.table` dans [la section sur les \"globales non définies\"](#globals)\n\n## Utilisation\n\nA titre d'exemple, nous allons définir deux fonctions dans le package `a.pkg` qui utilise `data.table`. Une fonction, `gen`, générera un simple `data.table` ; une autre, `aggr`, en fera une simple agrégation.\n\n```r\ngen = function (n = 100L) {\n dt = as.data.table(list(id = seq_len(n)))\n dt[, grp := ((id - 1) %% 26) + 1\n ][, grp := letters[grp]\n ][]\n}\naggr = function (x) {\n stopifnot(\n is.data.table(x),\n \"grp\" %in% names(x)\n )\n x[, .N, by = grp]\n}\n```\n\n## Tests\n\nAssurez-vous d'inclure des tests dans votre package. Avant chaque version majeure de `data.table`, nous vérifions les dépendances inverses. Cela signifie que si un changement dans `data.table` casse votre code, nous serons capables de repérer les changements et de vous en informer avant de publier la nouvelle version. Cela suppose bien sûr que vous publiiez votre package sur CRAN ou Bioconductor. Le test le plus basique peut être un script R en clair dans le répertoire `tests/test.R` de votre package :\n\n```r\nlibrary(a.pkg)\ndt = gen()\nstopifnot(nrow(dt) == 100)\ndt2 = aggr(dt)\nstopifnot(nrow(dt2) < 100)\n```\n\nLorsque vous testez votre package, vous pouvez utiliser `R CMD check --no-stop-on-test-error`, qui continuera après une erreur et exécutera tous vos tests (au lieu de s'arrêter à la première ligne du script qui a échoué).\n\n## Tester en utilisant `testthat`\n\nIl est très courant d'utiliser le package `testthat` pour effectuer des tests. Tester un package qui importe `data.table` n'est pas différent de tester d'autres packages. Un exemple de script de test `tests/testthat/test-pkg.R` :\n\n```r\ncontext(\"pkg tests\")\n\ntest_that(\"generate dt\", { expect_true(nrow(gen()) == 100) })\ntest_that(\"aggregate dt\", { expect_true(nrow(aggr(gen())) < 100) })\n```\n\nSi `data.table` est dans Suggests (mais pas dans Imports) alors vous devez déclarer `.datatable.aware=TRUE` dans un des fichiers R/* pour éviter les erreurs \"object not found\" lors des tests via `testthat::test_package` ou `testthat::test_check`.\n\n## Traitement des \"fonctions ou variables globales indéfinies\" (\"undefined global functions or variables\") {#globals}\n\nl'utilisation par `data.table` de l'évaluation différée de R (en particulier sur le côté gauche de `:=`) n'est pas bien reconnue par `R CMD check`. Il en résulte des `NOTE`s comme la suivante lors de la vérification du package :\n\n```\n* checking R code for possible problems ... NOTE\naggr: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'id'\nUndefined global functions or variables:\ngrp id\n```\n\n---\n\n6. `.()` can now be used in `j` and is identical to `list()`, for consistency with `i`.\n ```R\n DT[,list(MySum=sum(B)),by=...]\n DT[,.(MySum=sum(B)),by=...] # same\n DT[,list(colB,colC,colD)]\n DT[,.(colB,colC,colD)] # same\n ```\n Similarly, `by=.()` is now a shortcut for `by=list()`, for consistency with `i` and `j`.\n\n 7. `rbindlist` gains `use.names` and `fill` arguments and is now implemented entirely in C. Closes [#345](https://github.com/Rdatatable/data.table/issues/345):\n * `use.names` by default is FALSE for backwards compatibility (does not bind by names by default)\n * `rbind(...)` now just calls `rbindlist()` internally, except that `use.names` is TRUE by default, for compatibility with base (and backwards compatibility).\n * `fill=FALSE` by default. If `fill=TRUE`, `use.names` has to be TRUE.\n * When use.names=TRUE, at least one item of the input list has to have non-null column names.\n * When fill=TRUE, all items of the input list has to have non-null column names.\n * Duplicate columns are bound in the order of occurrence, like base.\n * Attributes that might exist in individual items would be lost in the bound result.\n * Columns are coerced to the highest SEXPTYPE when they are different, if possible.\n * And incredibly fast ;).\n * Documentation updated in much detail. Closes [#333](https://github.com/Rdatatable/data.table/issues/333).\n\n 8. `bit64::integer64` now works in grouping and joins, [#342](https://github.com/Rdatatable/data.table/issues/342). Thanks to James Sams for highlighting UPCs and Clayton Stanley for [this SO post](https://stackoverflow.com/questions/22273321/large-integers-in-data-table-grouping-results-different-in-1-9-2-compared-to-1). `fread()` has been detecting and reading `integer64` for a while.\n\n 9. `setNumericRounding()` may be used to reduce to 1 byte or 0 byte rounding when joining to or grouping columns of type 'numeric', [#342](https://github.com/Rdatatable/data.table/issues/342). See example in `?setNumericRounding` and NEWS item below for v1.9.2. `getNumericRounding()` returns the current setting.\n\n 10. `X[Y]` now names non-join columns from `i` that have the same name as a column in `x`, with an `i.` prefix for consistency with the `i.` prefix that has been available in `j` for some time. This is now documented.\n\n 11. For a keyed table `X` where the key columns are not at the beginning in order, `X[Y]` now retains the original order of columns in X rather than moving the join columns to the beginning of the result.\n\n 12. It is no longer an error to assign to row 0 or row NA.\n ```R\n DT[0, colA := 1L] # now does nothing, silently (was error)\n DT[NA, colA := 1L] # now does nothing, silently (was error)\n DT[c(1, NA, 0, 2), colA:=1L] # now ignores the NA and 0 silently (was error)\n DT[nrow(DT) + 1, colA := 1L] # error (out-of-range) as before\n ```\n This is for convenience to avoid the need for a switch in user code that evals various `i` conditions in a loop passing in `i` as an integer vector which may containing `0` or `NA`.\n\n 13. A new function `setorder` is now implemented which uses data.table's internal fast order to reorder rows *by reference*. It returns the result invisibly (like `setkey`) that allows for compound statements; e.g., `setorder(DT, a, -b)[, cumsum(c), by=list(a,b)]`. Check `?setorder` for more info.\n\n 14. `DT[order(x, -y)]` is now by default optimised to use data.table's internal fast order as `DT[forder(DT, x, -y)]`. It can be turned off by setting `datatable.optimize` to < 1L or just calling `base:::order` explicitly. It results in 20x speedup on data.table of 10 million rows with 2 integer columns, for example. To order character vectors in descending order it's sufficient to do `DT[order(x, -y)]` as opposed to `DT[order(x, -xtfrm(y))]` in base. This closes [#603](https://github.com/Rdatatable/data.table/issues/603).\n\n---\n\ndim.data.table = function(x)\n{\n .Call(Cdim, x)\n}\n\n.global = new.env() # thanks to: http://stackoverflow.com/a/12605694/403310\nmethods::setPackageName(\"data.table\",.global)\n.global$print = \"\"\n\n# NB: if adding to/editing this list, be sure to do the following:\n# (1) add to man/special-symbols.Rd\n# (2) export() in NAMESPACE\n# (3) add to vignettes/datatable-importing.Rmd#globals section\n.SD = .N = .I = .GRP = .NGRP = .BY = .EACHI = NULL\n# These are exported to prevent NOTEs from R CMD check, and checkUsage via compiler.\n# But also exporting them makes it clear (to users and other packages) that data.table uses these as symbols.\n# And NULL makes it clear (to the R's mask check on loading) that they're variables not functions.\n# utils::globalVariables(c(\".SD\",\".N\")) was tried as well, but exporting seems better.\n# So even though .BY doesn't appear in this file, it should still be NULL here and exported because it's\n# defined in SDenv and can be used by users.\n\nis.data.table = function(x) inherits(x, \"data.table\")\nis.ff = function(x) inherits(x, \"ff\") # define this in data.table so that we don't have to require(ff), but if user is using ff we'd like it to work\n\n#NCOL = function(x) {\n# # copied from base, but additionally covers data.table via is.list()\n# # because NCOL in base explicitly tests using is.data.frame()\n# if (is.list(x) && !is.ff(x)) return(length(x))\n# if (is.array(x) && length(dim(x)) > 1L) ncol(x) else as.integer(1L)\n#}\n#NROW = function(x) {\n# if (is.data.frame(x) || is.data.table(x)) return(nrow(x))\n# if (is.list(x) && !is.ff(x)) stopf(\"List is not a data.frame or data.table. Convert first before using NROW\") # list may have different length elements, which data.table and data.frame's resolve.\n# if (is.array(x)) nrow(x) else length(x)\n#}\n\nnull.data.table = function() {\n ans = list()\n setattr(ans,\"class\",c(\"data.table\",\"data.frame\"))\n setattr(ans,\"row.names\",.set_row_names(0L))\n setalloccol(ans)\n}\n\ndata.table = function(..., keep.rownames=FALSE, check.names=FALSE, key=NULL, stringsAsFactors=FALSE)\n{\n # NOTE: It may be faster in some circumstances for users to create a data.table by creating a list l\n # first, and then setattr(l,\"class\",c(\"data.table\",\"data.frame\")) and forgo checking.\n x = list(...) # list() doesn't copy named inputs as from R >= 3.1.0 (a very welcome change)\n nd = name_dots(...)\n names(x) = nd$vnames\n if (length(x)==0L) return( null.data.table() )\n if (length(x)==1L && (is.null(x[[1L]]) || (is.list(x[[1L]]) && length(x[[1L]])==0L))) return( null.data.table() ) #48\n ans = as.data.table.list(x, keep.rownames=keep.rownames, check.names=check.names, .named=nd$.named) # see comments inside as.data.table.list re copies\n if (!is.null(key)) {\n if (!is.character(key)) stopf(\"key argument of data.table() must be character\")\n if (length(key)==1L) key = cols_from_csv(key)\n setkeyv(ans,key)\n } else {\n # retain key of cbind(DT1, DT2, DT3) where DT2 is keyed but not DT1. cbind calls data.table().\n # If DT inputs with keys have been recycled then can't retain key\n ckey = NULL\n for (i in seq_along(x)) {\n xi = x[[i]]\n if (is.data.table(xi) && haskey(xi) && nrow(xi)==nrow(ans)) ckey=c(ckey, key(xi))\n }\n if (length(ckey) &&\n !anyDuplicated(ckey) &&\n identical(is.na(chmatchdup(c(ckey,ckey), names(ans))), rep(c(FALSE,TRUE),each=length(ckey)))) {\n setattr(ans, \"sorted\", ckey)\n }\n }\n if (isTRUE(stringsAsFactors)) {\n for (j in which(vapply_1b(ans, is.character))) set(ans, NULL, j, as_factor(.subset2(ans, j)))\n # as_factor is internal function in fread.R currently\n }\n setalloccol(ans) # returns a NAMED==0 object, unlike data.frame()\n}\n\n---\n\nEl caso de los símbolos especiales de `data.table` (p. ej., `.SD` y `.N`) y el operador de asignación (`:=`) es ligeramente diferente (consulte `?.N` para obtener más información, incluyendo una lista completa de dichos símbolos). Debe importar cualquiera de estos valores que utilice del espacio de nombres de `data.table` para evitar problemas derivados del improbable escenario de que cambiemos el valor exportado de estos en el futuro. Por ejemplo, si desea usar `.N`, `.I` y `:=`, un `NAMESPACE` mínimo tendría:\n\n```r\nimportFrom(data.table, .N, .I, ':=')\n```\n\nMucho más simple es simplemente usar `import(data.table)`, lo que permitirá el uso en el código de su paquete de cualquier objeto exportado desde `data.table`.\n\nSi no le importa tener `id` y `grp` registrados como variables globales en el espacio de nombres de su paquete, puede usar `?globalVariables`. Tenga en cuenta que estas notas no afectan el código ni su funcionalidad; si no va a publicar su paquete, puede simplemente ignorarlas.\n\n## Se debe tener cuidado al proporcionar y utilizar `options`\n\nUna práctica común en los paquetes de R es proporcionar opciones de personalización definidas por `options(name=val)` y obtenidas mediante `getOption(\"name\", default)`. Los argumentos de función suelen especificar una llamada a `getOption()` para que el usuario conozca (a través de `?fun` o `args(fun)`) el nombre de la opción que controla el valor predeterminado para ese parámetro; por ejemplo, `fun(..., verbose=getOption(\"datatable.verbose\", FALSE))`. Todas las opciones de `data.table` comienzan con `datatable.` para evitar conflictos con las opciones de otros paquetes. El usuario simplemente llama a `options(datatable.verbose=TRUE)` para activar la verbosidad. Esto afecta a todas las llamadas a la función data.table, a menos que `verbose=FALSE` se especifique explícitamente; por ejemplo, `fun(..., verbose=FALSE)`.\n\nEl mecanismo de opciones en R es *global*. Esto significa que si un usuario establece una opción `data.table` para su propio uso, esa configuración también afecta al código dentro de cualquier paquete que también esté usando `data.table`. Para una opción como `datatable.verbose`, este es exactamente el comportamiento deseado ya que el deseo es rastrear y registrar todas las operaciones de `data.table` desde donde sea que se originen; activar la verbosidad no afecta los resultados. Otra opción única de R y excelente para producción es `options(warn=2)` de R que convierte todas las advertencias en errores. Nuevamente, el deseo es afectar cualquier advertencia en cualquier paquete para no perder ninguna advertencia en producción. Hay 6 opciones `datatable.print.*` y 3 opciones de optimización que no afectan el resultado de las operaciones. Sin embargo, hay una opción `data.table` que sí afecta y ahora es una preocupación: `datatable.nomatch`. Esta opción cambia la unión predeterminada de externa a interna. [Aparte, la unión predeterminada es externa porque externa es más segura; no elimina los datos faltantes silenciosamente; Además, es coherente con el método R básico para la coincidencia por nombres e índices. Algunos usuarios prefieren que la unión interna sea la opción predeterminada, y les proporcionamos esta opción. Sin embargo, si un usuario configura esta opción, puede cambiar involuntariamente el comportamiento de las uniones dentro de paquetes que usan `data.table`. Por consiguiente, en la versión 1.12.4 (octubre de 2019) se mostraba un mensaje al usar la opción `datatable.nomatch`, y a partir de la versión 1.14.2, se ignora con una advertencia. Era la única opción de `data.table` con este problema.\n\n## Solución de problemas\n\nSi enfrenta algún problema al crear un paquete que usa data.table, confirme que el problema se pueda reproducir en una sesión R limpia usando la consola R: `R CMD check package.name`.\n\n---\n\n## Où sont les archives de datatable-help ?\n\nLa [page d'accueil](https://github.com/Rdatatable/data.table/wiki) contient des liens vers les archives en plusieurs formats.\n\n## Je préférerais ne pas publier sur la page \"Questions\" (Issues). Puis-je envoyer un email à une ou deux personnes ?\n\nBien sûr, mais il est plus probable que vous obteniez une réponse plus rapide sur la page Issues ou sur Stack Overflow. De plus, le fait de poser des questions publiquement à ces endroits aide à construire la base de connaissances générale.\n\n## J'ai créé un package qui utilise data.table. Comment puis-je m'assurer que mon package est compatible avec data.table pour que l'héritage de `data.frame` fonctionne ?\n\nVoir [cette réponse](https://stackoverflow.com/a/10529888/403310).\n\n```{r, echo=FALSE}\nsetDTthreads(.old.th)\n```\n\n---\n\n#include \"data.table.h\"\n#include \n\n// Wrappers for R internal functions. We can't rely on calling\n// Rf_setAttrib and Rf_duplicate directly from .Call in R on\n// all platforms, as we found out when v1.6.5 went to CRAN on\n// 25 Aug 2011, see Professor Ripley's response that day.\n\nSEXP setattrib(SEXP x, SEXP name, SEXP value)\n{\n if (!isString(name) || LENGTH(name)!=1) error(_(\"Attribute name must be a character vector of length 1\"));\n if (!isNewList(x) &&\n strcmp(CHAR(STRING_ELT(name,0)),\"class\")==0 &&\n isString(value) && LENGTH(value)>0 &&\n (strcmp(CHAR(STRING_ELT(value, 0)),\"data.table\")==0 || strcmp(CHAR(STRING_ELT(value,0)),\"data.frame\")==0) ) {\n error(_(\"Internal structure doesn't seem to be a list. Can't set class to be 'data.table' or 'data.frame'. Use 'as.data.table()' or 'as.data.frame()' methods instead.\"));\n }\n if (isLogical(x) && LENGTH(x)==1 &&\n (x==ScalarLogical(TRUE) || x==ScalarLogical(FALSE) || x==ScalarLogical(NA_LOGICAL))) { // R's internal globals, #1281\n x = PROTECT(duplicate(x));\n setAttrib(x, name, MAYBE_REFERENCED(value) ? duplicate(value) : value);\n UNPROTECT(1);\n return(x);\n }\n if (isNull(value) && isPairList(x) && strcmp(CHAR(STRING_ELT(name,0)),\"names\")==0) {\n // backport fix in R 3.2.0 to support R 3.1.0; #4048 #3802\n // apply this backport always (i.e. in R >=3.2.0 too) to avoid a switch on version number or feature test (to avoid more code, tests and nocov)\n for (SEXP t=x; t!=R_NilValue; t=CDR(t)) {\n SET_TAG(t, R_NilValue);\n }\n } else {\n setAttrib(x, name, MAYBE_REFERENCED(value) ? duplicate(value) : value);\n // duplicate is temp fix to restore R behaviour prior to R-devel change on 10 Jan 2014 (r64724).\n // TO DO: revisit. Enough to reproduce is: DT=data.table(a=1:3); DT[2]; DT[,b:=2]\n // ... Error: selfrefnames is ok but tl names [1] != tl [100]\n }\n return(R_NilValue);\n}\n\n// fix for #1142 - duplicated levels for factors\nSEXP setlevels(SEXP x, SEXP levels, SEXP ulevels) {\n\n R_len_t nx = length(x);\n SEXP xchar, newx;\n xchar = PROTECT(allocVector(STRSXP, nx));\n int *ix = INTEGER(x);\n const int nlevels = length(levels);\n for (int i=0; i= 1 && ixi <= nlevels) ? STRING_ELT(levels, ix[i]-1) : NA_STRING);\n }\n newx = PROTECT(chmatch(xchar, ulevels, NA_INTEGER));\n const int *inewx = INTEGER_RO(newx);\n for (int i=0; i3, .(ITEM='A>3', A, B)] # (1)\n DT[A>3][, .(ITEM='A>3', A, B)] # (2)\n # the above are now equivalent as expected and return:\n Empty data.table (0 rows and 3 cols): ITEM,A,B\n # Previously, (2) returned :\n ITEM A B\n \n 1: A>3 NA \n Warning messages:\n 1: In as.data.table.list(jval, .named = NULL) :\n Item 2 has 0 rows but longest item has 1; filled with NA\n 2: In as.data.table.list(jval, .named = NULL) :\n Item 3 has 0 rows but longest item has 1; filled with NA\n ```\n\n ```R\n DT = data.table(A=1:3, B=letters[1:3], key=\"A\")\n DT[.(1:3, double()), B]\n # new result :\n character(0)\n # old result :\n [1] \"a\" \"b\" \"c\"\n Warning message:\n In as.data.table.list(i) :\n Item 2 has 0 rows but longest item has 3; filled with NA\n ```\n\n5. `%like%` on factors with a large number of levels is now faster, [#4748](https://github.com/Rdatatable/data.table/issues/4748). The example in the PR shows 2.37s reduced to 0.86s on a factor length 100 million containing 1 million unique 10-character strings. Thanks to @statquant for reporting, and @shrektan for implementing.\n\n6. `keyby=` now accepts `TRUE`/`FALSE` together with `by=`, [#4307](https://github.com/Rdatatable/data.table/issues/4307). The primary motivation is benchmarking where `by=` vs `keyby=` is varied across a set of queries. Thanks to Jan Gorecki for the request and the PR.\n\n ```R\n DT[, sum(colB), keyby=\"colA\"]\n DT[, sum(colB), by=\"colA\", keyby=TRUE] # same\n ```\n\n7. `fwrite()` gains a new `datatable.fwrite.sep` option to change the default separator, still `\",\"` by default. Thanks to Tony Fischetti for the PR. As is good practice in R in general, we usually resist new global options for the reason that a user changing the option for their own code can inadvertently change the behaviour of any package using `data.table` too. However, in this case, the global option affects file output rather than code behaviour. In fact, the very reason the user may wish to change the default separator is that they know a different separator is more appropriate for their data being passed to the package using `fwrite` but cannot otherwise change the `fwrite` call within that package.\n\n8. `melt()` now supports `NA` entries when specifying a list of `measure.vars`, which translate into runs of missing values in the output. Useful for melting wide data with some missing columns, [#4027](https://github.com/Rdatatable/data.table/issues/4027). Thanks to @vspinu for reporting, and @tdhock for implementing.\n\n---\n\nHistorical note: \\code{melt.data.table} was originally designed as an enhancement to \\code{reshape2::melt} in terms of computing and memory efficiency. \\code{reshape2} has since been superseded in favour of \\code{tidyr}, and \\code{melt} has had a generic defined within \\code{data.table} since \\code{v1.9.6} in 2015, at which point the dependency between the packages became more etymological than programmatic. We thank the \\code{reshape2} authors for the inspiration.\n\n}\n\n\\value{\nAn unkeyed \\code{data.table} containing the molten data.\n}\n\n\\examples{\nset.seed(45)\nrequire(data.table)\nDT <- data.table(\n i_1 = c(1:5, NA),\n n_1 = c(NA, 6, 7, 8, 9, 10),\n f_1 = factor(sample(c(letters[1:3], NA), 6L, TRUE)),\n f_2 = factor(c(\"z\", \"a\", \"x\", \"c\", \"x\", \"x\"), ordered=TRUE),\n c_1 = sample(c(letters[1:3], NA), 6L, TRUE),\n c_2 = sample(c(LETTERS[1:2], NA), 6L, TRUE),\n d_1 = as.Date(c(1:3,NA,4:5), origin=\"2013-09-01\"),\n d_2 = as.Date(6:1, origin=\"2012-01-01\")\n)\n# add a couple of list cols\nDT[, l_1 := DT[, list(c=list(rep(i_1, sample(5, 1L)))), by = i_1]$c]\nDT[, l_2 := DT[, list(c=list(rep(c_1, sample(5, 1L)))), by = i_1]$c]\n\n# id.vars, measure.vars as character/integer/numeric vectors\nmelt(DT, id.vars=1:2, measure.vars=\"f_1\")\nmelt(DT, id.vars=c(\"i_1\", \"n_1\"), measure.vars=3) # same as above\nmelt(DT, id.vars=1:2, measure.vars=3L, value.factor=TRUE) # same, but 'value' is factor\nmelt(DT, id.vars=1:2, measure.vars=3:4, value.factor=TRUE) # 'value' is *ordered* factor\n\n# preserves attribute when types are identical, ex: Date\nmelt(DT, id.vars=3:4, measure.vars=c(\"d_1\", \"d_2\"))\nmelt(DT, id.vars=3:4, measure.vars=c(\"n_1\", \"d_1\")) # attribute not preserved\n\n# on list\nmelt(DT, id.vars=1, measure.vars=c(\"l_1\", \"l_2\")) # value is a list\nsuppressWarnings(\n melt(DT, id.vars=1, measure.vars=c(\"c_1\", \"l_1\")) # c1 coerced to list, with warning\n)\n\n# on character\nmelt(DT, id.vars=1, measure.vars=c(\"c_1\", \"f_1\")) # value is char\nsuppressWarnings(\n melt(DT, id.vars=1, measure.vars=c(\"c_1\", \"n_1\")) # n_1 coerced to char, with warning\n)\n\n# on na.rm=TRUE. NAs are removed efficiently, from within C\nmelt(DT, id.vars=1, measure.vars=c(\"c_1\", \"c_2\"), na.rm=TRUE) # remove NA\n\n# measure.vars can be also a list\n# melt \"f_1,f_2\" and \"d_1,d_2\" simultaneously, retain 'factor' attribute\n# convenient way using internal function patterns()\nmelt(DT, id.vars=1:2, measure.vars=patterns(\"^f_\", \"^d_\"), value.factor=TRUE)\nmelt(DT, id.vars=patterns(\"[in]\"), measure.vars=patterns(\"^f_\", \"^d_\"), value.factor=TRUE)\n# same as above, but provide list of columns directly by column names or indices\nmelt(DT, id.vars=1:2, measure.vars=list(3:4, c(\"d_1\", \"d_2\")), value.factor=TRUE)\n# same as above, but provide names directly:\nmelt(DT, id.vars=1:2, measure.vars=patterns(f=\"^f_\", d=\"^d_\"), value.factor=TRUE)\n\n# na.rm=TRUE removes rows with NAs in any 'value' columns\nmelt(DT, id.vars=1:2, measure.vars=patterns(\"f_\", \"d_\"), value.factor=TRUE, na.rm=TRUE)\n\n# 'na.rm=TRUE' also works with list column, but note that is.na only\n# returns TRUE if the list element is a length=1 vector with an NA.\nis.na(list(one.NA=NA, two.NA=c(NA,NA)))\nmelt(DT, id.vars=1:2, measure.vars=patterns(\"l_\", \"d_\"), na.rm=FALSE)\nmelt(DT, id.vars=1:2, measure.vars=patterns(\"l_\", \"d_\"), na.rm=TRUE)\n\n# measure list with missing/short entries results in output with runs of NA\nDT.missing.cols <- DT[, .(d_1, d_2, c_1, f_2)]\nmelt(DT.missing.cols, measure.vars=list(d=1:2, c=\"c_1\", f=c(NA, \"f_2\")))\n\n# specifying columns to melt via separator.\nmelt(DT.missing.cols, measure.vars=measure(value.name, number=as.integer, sep=\"_\"))\n\n# specifying columns to melt via regex.\nmelt(DT.missing.cols, measure.vars=measure(value.name, number=as.integer, pattern=\"(.)_(.)\"))\nmelt(DT.missing.cols, measure.vars=measure(value.name, number=as.integer, pattern=\"([dc])_(.)\"))\n\n---\n\nFuture talks\n\nPast talks\n\n2025.06.27: Toby Hocking, Time and memory efficient R programming, French slides for R Ladies Paris online meetup, video.\n\n2025.06.24: What makes R strong - Atelier Global Actuarial Conference, Zurich, Switzerland - by Jan Gorecki, slides.\n\n2025.05.19: Toby Hocking, French slides for data.table tutorial at Recontres R, Mons, Belgium, data.table pour la traitement efficace des grands jeux de données.\n\n2025.05.15: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Bernd Bischl's lab meeting at LMU in Munich, slides.\n\n2025.05.08: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Zurich Applied Statistics seminar, announcement, slides.\n\n2025.03: Toby Hocking, Short talk about data.table for Julie Josse lab in Montpellier, slides\n\n2025.02: Toby Hocking, Madrid R User Group, Video.\n\n2024.12: Toby Hocking, PyData Global, Dec 2024, Video.\n\n2024.11.07: R package dependencies in production - III Congress & XIV R User Conference, Sevilla, Spain - by Jan Gorecki, slides.\n\n2024.10.15: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, \"Women in Statistics and Data Science conference 2024\" Presentation Speed Talk and Poster Presentation\n\n2024.08.06: \"Creating a self-sustaining ecosystem for data.table\" by Ani, JSM 2024 (Portland, Oregon), Slides\n\n2024.08.06: Tyson S. Barrett, \"Efficient Tools for Your Tidy Workflow: A case for incorporating data.table\", JSM 2024 in Portland, OR slides\n\n2024.07.11: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, useR! 2024 online presentation video, useR! 2024 presentation in Salzburg, Austria slides\n\n2024.07.09: Tyson S. Barrett, \"The Past, Present, and Future of data.table\", useR! 2024 presentation in Salzburg, Austria slides\n\n2024.05.18: Tyson S. Barrett, \"data.table: New Developments\", R Finance 2024 presentation in Chicago slides\n\n2024.03.28: Toby Dylan Hocking, R Project in Google Summer of Code, virtual talk for Chicago R User Group, slides.\n\n2024.03.05: \"GitHub Actions: Automated performance regression testing on pull requests\" by Ani, NAU SICCS (Flagstaff, AZ), Slides\n\n2024.02.29: David Shilane, R Programming: Introduction to data.table, course at Conference on Statistical Practice (CSP2024), slides and practice exercises\n\n2024.02.08: intro to data.table at SevillaR: High productivity data frame operations with data.table, by Jan Gorecki, slides, video.\n\n2024.01.26: Rolling statistics - Edinburgh R user group meeting, Edinburgh, United Kingdom, by Jan Gorecki, slides\n\n2023.10.18: Using and contributing to the data.table package for efficient big data analysis - LatinR meeting, Montevideo, Uruguay. * Original presentation by Toby Dylan Hocking, google slides, source files. * Spanish translation by Mara Destefanis.\n\n2020.04: Manejo eficiente de grandes volúmenes de datos usando el paquete data.table en R - Nestor Montano, Diapositivas Youtube Playlist Facebook Playlist\n\n2020.04: Data wrangling and cleaning with data.table - Grant McDermott, Big Data in Economics (UOregon)\n\n2020.02.01: Machine Learning and Data Munging in H2O Driverless AI with (python) datatable - Parul Pandey, Hyderabad AI & DL meetup\n\n2020.01.30: List-columns in data.table - Tyson Barrett, rstudio::conf(2020L)\n\n2019.12.26: Efficiency in data processing. data.table basics - Jan Gorecki, R@IISA 2019\n\n2019.10 : data.table for R and Python, Matt Dowle, H2OWorld New York\n\n2019.10 : Why I love data.table, Chris Mainey, Warwick R User Group\n\n2019.09 : Introduction to data.table, Jan Gorecki, whyR? Warsaw\n\n2019.07 : Not So Standard Deviations; 84 - All The Easy Issues, Hilary Parker and Roger Peng\n\n2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk\n\n2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse\n\n---\n\n## Why do `T` and `F` behave differently from `TRUE` and `FALSE` in some `data.table` queries?\n\nUsing `T` and `F` as abbreviations for `TRUE` and `FALSE` in `data.table` can lead to unexpected behavior. This is because `T` and `F` are global variables that can be redefined, which causes them to be treated as variable names rather than logical constants. This issue does not occur with `TRUE` and `FALSE`. Avoiding `T` and `F` is advice for using R generally, but it shows up in `data.table` in some perhaps surprising ways, for example:\n\n```r\nDT <- data.table(x=rep(c(\"a\", \"b\", \"c\"), each = 3), y=c(1, 3, 6), v=1:9)\n\n# Using TRUE/FALSE works as expected in cases like the ones below:\n\nDT[, .SD, .SDcols=c(TRUE, TRUE, FALSE)]\n# A) This selects the first two columns (x and y) and excludes the third one (v). Output:\n#> x y\n#> 1: a 1\n#> 2: a 3\n#> 3: a 6\n#> 4: b 1\n#> 5: b 3\n#> 6: b 6\n#> 7: c 1\n#> 8: c 3\n#> 9: c 6\n\nDT[, .SD, .SDcols=c(T, T, F), with=FALSE]\n# B) This forces data.table to treat T/F as logical constants.\n# Same output as DT[, .SD, .SDcols=c(TRUE, TRUE, FALSE)]\n\n# But, using T/F may lead to unexpected behavior in cases like:\n\nDT[, .SD, .SDcols=c(T, T, F)]\n# data.table treats T and F as variable names here, not logical constants. Output:\n#> Detected that j uses these columns: \n#> [1] TRUE TRUE FALSE\n```\n\nAs a general word of advice, `lintr::T_and_F_symbol_linter()` detects the usage of `T` and `F` and suggests replacing them with `TRUE` and `FALSE` to avoid such issues.\n\n# Questions relating to compute time\n\n## I have 20 columns and a large number of rows. Why is an expression of one column so quick?\n\nSeveral reasons:\n\n - Only that column is grouped, the other 19 are ignored because data.table inspects the `j` expression and realises it doesn't use the other columns.\n - One memory allocation is made for the largest group only, then that memory is re-used for the other groups. There is very little garbage to collect.\n - R is an in-memory column store; i.e., the columns are contiguous in RAM. Page fetches from RAM into L2 cache are minimised.\n\n## I don't have a `key` on a large table, but grouping is still really quick. Why is that?\n\ndata.table uses radix sorting. This is significantly faster than other sort algorithms. See [our presentations](https://github.com/Rdatatable/data.table/wiki/Presentations) for more information, in particular from useR!2015 Denmark.\n\nThis is also one reason why `setkey()` is quick.\n\nWhen no `key` is set, or we group in a different order from that of the key, we call it an _ad hoc_ `by`.\n\n## Why is grouping by columns in the key faster than an _ad hoc_ `by`?\n\nBecause each group is contiguous in RAM, thereby minimising page fetches and memory can be\ncopied in bulk (`memcpy` in C) rather than looping in C.\n\n## What are primary and secondary indexes in data.table?\n\nManual: [`?setkey`](https://www.rdocumentation.org/packages/data.table/functions/setkey)\nS.O.: [What is the purpose of setting a key in data.table?](https://stackoverflow.com/questions/20039335/what-is-the-purpose-of-setting-a-key-in-data-table/20057411#20057411)\n\n`setkey(DT, col1, col2)` orders the rows by column `col1` then within each group of `col1` it orders by `col2`. This is a _primary index_. The row order is changed _by reference_ in RAM. Subsequent joins and groups on those key columns then take advantage of the sort order for efficiency. (Imagine how difficult looking for a phone number in a printed telephone directory would be if it wasn't sorted by surname then forename. That's literally all `setkey` does. It sorts the rows by the columns you specify.) The index doesn't use any RAM. It simply changes the row order in RAM and marks the key columns. Analogous to a _clustered index_ in SQL.\n\n---\n\n#include \"data.table.h\"\n\n---\n\n#include \"data.table.h\"\n\n---\n\n3. When `j` contains no unquoted variable names (whether column names or not), `with=` is now automatically set to `FALSE`. Thus, `DT[,1]`, `DT[,\"someCol\"]`, `DT[,c(\"colA\",\"colB\")]` and `DT[,100:109]` now work as we all expect them to; i.e., returning columns, [#1188](https://github.com/Rdatatable/data.table/issues/1188), [#1149](https://github.com/Rdatatable/data.table/issues/1149). Since there are no variable names there is no ambiguity as to what was intended. `DT[,colName1:colName2]` no longer needs `with=FALSE` either since that is also unambiguous. That is a single call to the `:` function so `with=TRUE` could make no sense, despite the presence of unquoted variable names. These changes can be made since nobody can be using the existing behaviour of returning back the literal `j` value since that can never be useful. This provides a new ability and should not break any existing code. Selecting a single column still returns a 1-column data.table (not a vector, unlike `data.frame` by default) for type consistency for code (e.g. within `DT[...][...]` chains) that can sometimes select several columns and sometime one, as has always been the case in data.table. In future, `DT[,myCols]` (i.e. a single variable name) will look for `myCols` in calling scope without needing to set `with=FALSE` too, just as a single symbol appearing in `i` does already. The new behaviour can be turned on now by setting the tersely named option: `options(datatable.WhenJisSymbolThenCallingScope=TRUE)`. The default is currently `FALSE` to give you time to change your code. In this future state, one way (i.e. `DT[,theColName]`) to select the column as a vector rather than a 1-column data.table will no longer work leaving the two other ways that have always worked remaining (since data.table is still just a `list` after all): `DT[[\"someCol\"]]` and `DT$someCol`. Those base R methods are faster too (when iterated many times) by avoiding the small argument checking overhead inside the more flexible `DT[...]` syntax as has been highlighted in `example(data.table)` for many years. In the next release, `DT[,someCol]` will continue with old current behaviour but start to warn if the new option is not set. Then the default will change to TRUE to nudge you to move forward whilst still retaining a way for you to restore old behaviour for this feature only, whilst still allowing you to benefit from other new features of the latest release without changing your code. Then finally after an estimated 2 years from now, the option will be removed.\n\n### NEW FEATURES\n\n 1. `fwrite()` - parallel .csv writer:\n * Thanks to Otto Seiskari for the initial pull request [#580](https://github.com/Rdatatable/data.table/issues/580) that provided C code, R wrapper, manual page and extensive tests.\n * From there Matt parallelized and specialized C functions for writing integer/numeric exactly matching `write.csv` between 2.225074e-308 and 1.797693e+308 to 15 significant figures, dates (between 0000-03-01 and 9999-12-31), times down to microseconds in POSIXct, automatic quoting, `bit64::integer64`, `row.names` and `sep2` for `list` columns where each cell can itself be a vector. See [this blog post](https://blog.h2o.ai/2016/04/fast-csv-writing-for-r/) for implementation details and benchmarks.\n * Accepts any `list` of same length vectors; e.g. `data.frame` and `data.table`.\n * Caught in development before release to CRAN: thanks to Francesco Grossetti for [#1725](https://github.com/Rdatatable/data.table/issues/1725) (NA handling), Torsten Betz for [#1847](https://github.com/Rdatatable/data.table/issues/1847) (rounding of 9.999999999999998) and @ambils for [#1903](https://github.com/Rdatatable/data.table/issues/1903) (> 1 million columns).\n * `fwrite` status was tracked here: [#1664](https://github.com/Rdatatable/data.table/issues/1664)\n\n---\n\n9. `print.data.table()` (all via master issue [#1523](https://github.com/Rdatatable/data.table/issues/1523)):\n\n * gains `print.keys` argument, `FALSE` by default, which displays the keys and/or indices (secondary keys) of a `data.table`. Thanks @MichaelChirico for the PR, Yike Lu for the suggestion and Arun for honing that idea to its present form.\n\n * gains `col.names` argument, `\"auto\"` by default, which toggles which registers of column names to include in printed output. `\"top\"` forces `data.frame`-like behavior where column names are only ever included at the top of the output, as opposed to the default behavior which appends the column names below the output as well for longer (>20 rows) tables. `\"none\"` shuts down column name printing altogether. Thanks @MichaelChirico for the PR, Oleg Bondar for the suggestion, and Arun for guiding commentary.\n\n * list columns would print the first 6 items in each cell followed by a comma if there are more than 6 in that cell. Now it ends \",...\" to make it clearer, part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). Thanks to @franknarf1 for drawing attention to an issue raised on Stack Overflow by @TMOTTM [here](https://stackoverflow.com/q/47679701).\n\n10. `setkeyv` accelerated if key already exists [#2331](https://github.com/Rdatatable/data.table/issues/2331). Thanks to @MarkusBonsch for the PR.\n\n11. Keys and indexes are now partially retained up to the key column assigned to with ':=' [#2372](https://github.com/Rdatatable/data.table/issues/2372). They used to be dropped completely if any one of the columns was affected by `:=`. Tanks to @MarkusBonsch for the PR.\n\n12. Faster `as.IDate` and `as.ITime` methods for `POSIXct` and `numeric`, [#1392](https://github.com/Rdatatable/data.table/issues/1392). Thanks to Jan Gorecki for the PR.\n\n13. `unique(DT)` now returns `DT` early when there are no duplicates to save RAM, [#2013](https://github.com/Rdatatable/data.table/issues/2013). Thanks to Michael Chirico for the PR, and thanks to @mgahan for pointing out a reversion in `na.omit.data.table` before release, [#2660](https://github.com/Rdatatable/data.table/issues/2660#issuecomment-371027948).\n\n14. `uniqueN()` is now faster on logical vectors. Thanks to Hugh Parsonage for [PR#2648](https://github.com/Rdatatable/data.table/pull/2648).\n\n ```R\n N = 1e9\n # was now\n x = c(TRUE,FALSE,NA,rep(TRUE,N)) #\n uniqueN(x) == 3 # 5.4s 0.00s\n x = c(TRUE,rep(FALSE,N), NA) #\n uniqueN(x,na.rm=TRUE) == 2 # 5.4s 0.00s\n x = c(rep(TRUE,N),FALSE,NA) #\n uniqueN(x) == 3 # 6.7s 0.38s\n ```\n\n15. Subsetting optimization with keys and indices is now possible for compound queries like `DT[a==1 & b==2]`, [#2472](https://github.com/Rdatatable/data.table/issues/2472).\nThanks to @MichaelChirico for reporting and to @MarkusBonsch for the implementation.\n\n16. `melt.data.table` now offers friendlier functionality for providing `value.name` for `list` input to `measure.vars`, [#1547](https://github.com/Rdatatable/data.table/issues/1547). Thanks @MichaelChirico and @franknarf1 for the suggestion and use cases, @jangorecki and @mrdwab for implementation feedback, and @MichaelChirico for ultimate implementation.\n\n17. `update.dev.pkg` is new function to update package from development repository, it will download package sources only when newer commit is available in repository. `data.table::update.dev.pkg()` defaults updates `data.table`, but any package can be used.\n\n18. Item 1 in NEWS for [v1.10.2](https://github.com/Rdatatable/data.table/blob/master/NEWS.md#changes-in-v1102--on-cran-31-jan-2017) on CRAN in Jan 2017 included :\n\n---\n\nAn _empty_ data.table (`DT[0]`) has one or more columns, all of which are empty. Those empty columns still have names and types.\n\n```{r}\nDT = data.table(a = 1:3, b = c(4, 5, 6), d = c(7L,8L,9L))\nDT[0]\nsapply(DT[0], class)\n```\n\n## Why has the `DT()` alias been removed? {#DTremove1}\n`DT` was introduced originally as a wrapper for a list of `j `expressions. Since `DT` was an alias for data.table, this was a convenient way to take care of silent recycling in cases where each item of the `j` list evaluated to different lengths. The alias was one reason grouping was slow, though.\n\nAs of v1.3, `list()` or `.()` should be passed instead to the `j` argument. These are much faster, especially when there are many groups. Internally, this was a non-trivial change. Vector recycling is now done internally, along with several other speed enhancements for grouping.\n\n## But my code uses `j = DT(...)` and it works. The previous FAQ says that `DT()` has been removed. {#DTremove2}\n\nThen you are using a version prior to 1.5.3. Prior to 1.5.3 `[.data.table` detected use of `DT()` in the `j` and automatically replaced it with a call to `list()`. This was to help the transition for existing users.\n\n## What are the scoping rules for `j` expressions?\n\nThink of the subset as an environment where all the column names are variables. When a variable `foo` is used in the `j` of a query such as `X[Y, sum(foo)]`, `foo` is looked for in the following order:\n\n 1. The scope of `X`'s subset; _i.e._, `X`'s column names.\n 2. The scope of each row of `Y`; _i.e._, `Y`'s column names (_join inherited scope_)\n 3. The scope of the calling frame; _e.g._, the line that appears before the data.table query.\n 4. Exercise for reader: does it then ripple up the calling frames, or go straight to `globalenv()`?\n 5. The global environment\n\nThis is _lexical scoping_ as explained in [R FAQ 3.3.1](https://cran.r-project.org/doc/FAQ/R-FAQ.html#Lexical-scoping). The environment in which the function was created is not relevant, though, because there is _no function_. No anonymous _function_ is passed to `j`. Instead, an anonymous _body_ is passed to `j`; for example,\n\n```{r}\nDT = data.table(x = rep(c(\"a\", \"b\"), c(2, 3)), y = 1:5)\nDT\nDT[ , {z = sum(y); z + 3}, by = x]\n```\n\nSome programming languages call this a _lambda_.\n\n## Can I trace the `j` expression as it runs through the groups? {#j-trace}\n\nTry something like this:\n\n```{r}\nDT[ , {\n cat(\"Objects:\", paste(objects(), collapse = \",\"), \"\\n\")\n cat(\"Trace: x=\", as.character(x), \" y=\", y, \"\\n\")\n sum(y)},\n by = x]\n```\n\n## Inside each group, why are the group variables length-1?\n\n[Above](#j-trace), `x` is a grouping variable and (as from v1.6.1) has `length` 1 (if inspected or used in `j`). It's for efficiency and convenience. Therefore, there is no difference between the following two statements:\n\n```{r}\nDT[ , .(g = 1, h = 2, i = 3, j = 4, repeatgroupname = x, sum(y)), by = x]\nDT[ , .(g = 1, h = 2, i = 3, j = 4, repeatgroupname = x[1], sum(y)), by = x]\n```\n\nIf you need the size of the current group, use `.N` rather than calling `length()` on any column.\n\n## Only the first 10 rows are printed, how do I print more?\n\nThere are two things happening here. First, if the number of rows in a data.table are large (`> 100` by default), then a summary of the data.table is printed to the console by default. Second, the summary of a large data.table is printed by taking the top and bottom `n` (`= 5` by default) rows of the data.table and only printing those. Both of these parameters (when to trigger a summary and how much of a table to use as a summary) are configurable by R's `options` mechanism, or by calling the `print` function directly.\n\n---\n\n# data.table news and updates (historical)\n\n**This is OLD NEWS. Latest news is on GitHub [here](https://github.com/Rdatatable/data.table/blob/master/NEWS.md).**\n\n## data.table [v1.14.10](https://github.com/Rdatatable/data.table/milestone/20?closed=1) (8 Dec 2023)\n\n### NOTES\n\n1. Maintainer of the package for CRAN releases is from now on Tyson Barrett (@tysonstanley), [#5710](https://github.com/Rdatatable/data.table/issues/5710).\n\n2. Updated internal code for breaking change of `is.atomic(NULL)` in R-devel, [#5691](https://github.com/Rdatatable/data.table/pull/5691). Thanks to Martin Maechler for the patch.\n\n3. Fix multiple test concerning coercion to missing complex numbers, [#5695](https://github.com/Rdatatable/data.table/issues/5695) and [#5748](https://github.com/Rdatatable/data.table/issues/5748). Thanks to @MichaelChirico and @ben-schwen for the patches.\n\n4. Fix multiple format warnings (e.g., -Wformat) [#5712](https://github.com/Rdatatable/data.table/pull/5712), [#5781](https://github.com/Rdatatable/data.table/pull/5781), [#5800](https://github.com/Rdatatable/data.table/pull/5800), [#5786](https://github.com/Rdatatable/data.table/pull/5786). Thanks to @MichaelChirico and @jangorecki for the patches.\n\n\n## data.table [v1.14.8](https://github.com/Rdatatable/data.table/milestone/28?closed=1) (17 Feb 2023)\n\n### NOTES\n\n1. Test 1613.605 now passes changes to `as.data.frame()` in R-devel, [#5597](https://github.com/Rdatatable/data.table/pull/5597). Thanks to Avraham Adler for reporting.\n\n2. An out of bounds read when combining non-equi join with `by=.EACHI` has been found and fixed thanks to clang ASAN, [#5598](https://github.com/Rdatatable/data.table/issues/5598). There was no bug or consequence because the read was followed (now preceded) by a bounds test.\n\n3. `.rbind.data.table` (note the leading `.`) is no longer exported when `data.table` is installed in R>=4.0.0 (Apr 2020), [#5600](https://github.com/Rdatatable/data.table/pull/5600). It was never documented which R-devel now detects and warns about. It is only needed by `data.table` internals to support R<4.0.0; see note 1 in v1.12.6 (Oct 2019) below in this file for more details.\n\n\n## data.table [v1.14.6](https://github.com/Rdatatable/data.table/milestone/27?closed=1) (16 Nov 2022)\n\n### BUG FIXES\n\n1. `fread()` could leak memory, [#3292](https://github.com/Rdatatable/data.table/issues/3292). Thanks to @patrickhowerter for reporting, and Jim Hester for the fix. The fix requires R 3.4.0 or later. Loading `data.table` in earlier versions now highlights this issue on startup, asks users to upgrade R, and warns that we intend to upgrade `data.table`'s dependency from 8 year old R 3.1.0 (April 2014) to 5 year old R 3.4.0 (April 2017).\n\n### NOTES\n\n1. Test 1962.098 has been modified to pass latest changes to `POSIXt` in R-devel.\n\n2. `test.data.table()` no longer creates `DT` in `.GlobalEnv`, a CRAN policy violation, [#5514](https://github.com/Rdatatable/data.table/issues/5514). No other writes occurred to `.GlobalEnv` and release procedures have been improved to prevent this happening again.\n\n3. The memory usage of the test suite has been halved, [#5507](https://github.com/Rdatatable/data.table/issues/5507).\n\n\n## data.table [v1.14.4](https://github.com/Rdatatable/data.table/milestone/26?closed=1) (17 Oct 2022)\n\n### NOTES\n\n1. gcc 12.1 (May 2022) now detects and warns about an always-false condition (`-Waddress`) in `fread` which caused a small efficiency saving never to be invoked, [#5476](https://github.com/Rdatatable/data.table/pull/5476). Thanks to CRAN for testing latest versions of compilers.\n\n---\n\n### NOTES\n\n1. `rbindlist`'s `use.names=\"check\"` now emits its message for automatic column names (`\"V[0-9]+\"`) too, [#3484](https://github.com/Rdatatable/data.table/pull/3484). See news item 5 of v1.12.2 below.\n\n2. Adding a new column by reference using `set()` on a `data.table` loaded from binary file now give a more helpful error message, [#2996](https://github.com/Rdatatable/data.table/issues/2996). Thanks to Joseph Burling for reporting.\n\n ```\n This data.table has either been loaded from disk (e.g. using readRDS()/load()) or constructed\n manually (e.g. using structure()). Please run setDT() or alloc.col() on it first (to pre-allocate\n space for new columns) before adding new columns by reference to it.\n ```\n\n3. `setorder` on a superset of a keyed `data.table`'s key now retains its key, [#3456](https://github.com/Rdatatable/data.table/issues/3456). For example, if `a` is the key of `DT`, `setorder(DT, a, -v)` will leave `DT` keyed by `a`.\n\n4. New option `options(datatable.quiet = TRUE)` turns off the package startup message, [#3489](https://github.com/Rdatatable/data.table/issues/3489). `suppressPackageStartupMessages()` continues to work too. Thanks to @leobarlach for the suggestion inspired by `options(tidyverse.quiet = TRUE)`. We don't know of a way to make a package respect the `quietly=` option of `library()` and `require()` because the `quietly=` isn't passed through for use by the package's own `.onAttach`. If you can see how to do that, please submit a patch to R.\n\n5. When loading a `data.table` from disk (e.g. with `readRDS`), best practice is to run `setDT()` on the new object to assure it is correctly allocated memory for new column pointers. Barring this, unexpected behavior can follow; for example, if you assign a new column to `DT` from a function `f`, the new columns will only be assigned within `f` and `DT` will be unchanged. The `verbose` messaging in this situation is now more helpful, [#1729](https://github.com/Rdatatable/data.table/issues/1729). Thanks @vspinu for sharing his experience to spur this.\n\n6. New vignette _Using `.SD` for Data Analysis_, a deep dive into use cases for the `.SD` variable to help illuminate this topic which we've found to be a sticking point for beginning and intermediate `data.table` users, [#3412](https://github.com/Rdatatable/data.table/issues/3412).\n\n7. Added a note to `?frank` clarifying that ranking is being done according to C sorting (i.e., like `forder`), [#2328](https://github.com/Rdatatable/data.table/issues/2328). Thanks to @cguill95 for the request.\n\n8. Historically, `dcast` and `melt` were built as enhancements to `reshape2`'s own `dcast`/`melt`. We removed dependency on `reshape2` in v1.9.6 but maintained some backward compatibility. As that package has been superseded since December 2017, we will begin to formally complete the split from `reshape2` by removing some last vestiges. In particular we now warn when redirecting to `reshape2` methods and will later error before ultimately completing the split; see [#3549](https://github.com/Rdatatable/data.table/issues/3549) and [#3633](https://github.com/Rdatatable/data.table/issues/3633). We thank the `reshape2` authors for their original inspiration for these functions, and @ProfFancyPants for testing and reporting regressions in dev which have been fixed before release.\n\n9. `DT[col]` where `col` is a column containing row numbers of itself to select, now suggests the correct syntax (`DT[(col)]` or `DT[DT$col]`), [#697](https://github.com/Rdatatable/data.table/issues/697). This expands the message introduced in [#1884](https://github.com/Rdatatable/data.table/issues/1884) for the case where `col` is type `logical` and `DT[col==TRUE]` is suggested.\n\n---\n\n# Ensure that data.table options in code match documentation\noptions_documentation_linter = function(rd_file) {\n if (!grepl(\"\\\\name{data.table-options}\", readChar(rd_file, 100L), fixed = TRUE)) return(invisible())\n\n # Find options in R code\n walk_r_ast_for_options = function(expr) {\n if (is.call(expr) && length(expr) >= 2L && identical(expr[[1L]], quote(getOption)) && is.character(e2 <- expr[[2L]]) && startsWith(e2, \"datatable.\")) {\n e2\n } else if (is.recursive(expr)) {\n unlist(lapply(expr, walk_r_ast_for_options))\n }\n }\n\n # Find options in documentation\n walk_rd_ast_for_options = function(rd_element) {\n if (!is.list(rd_element)) return(character())\n\n result = character()\n if (isTRUE(attr(rd_element, \"Rd_tag\") == \"\\\\code\") && length(rd_element) >= 1L) {\n content = rd_element[[1L]]\n if (is.character(content) && startsWith(content, \"datatable.\")) {\n result = content\n }\n }\n c(result, unlist(lapply(rd_element, walk_rd_ast_for_options)))\n }\n\n code_opts = list.files(\"R\", pattern = \"\\\\.R$\", full.names = TRUE) |>\n lapply(\\(f) lapply(parse(f), walk_r_ast_for_options)) |>\n unlist() |>\n unique() |>\n setdiff(\"datatable.nomatch\") # ignore deprecated option(s)\n\n doc_opts = rd_file |>\n tools::parse_Rd() |>\n walk_rd_ast_for_options() |>\n unique()\n\n miss_in_doc = setdiff(code_opts, doc_opts)\n miss_in_code = setdiff(doc_opts, code_opts)\n\n if (length(miss_in_doc) > 0L || length(miss_in_code) > 0L) {\n if (length(miss_in_doc) > 0L) {\n cat(sprintf(\"Options in code but missing from docs: %s\\n\", toString(miss_in_doc)))\n }\n if (length(miss_in_code) > 0L) {\n cat(sprintf(\"Options in docs but not in code: %s\\n\", toString(miss_in_code)))\n }\n stop(\"Please sync man/data.table-options.Rd with code options\")\n }\n}\n\n---\n\n\\name{cdt}\n\\alias{cdatatable}\n\\title{ data.table exported C routines }\n\\description{\n Some of the internally used C routines are now exported. This interface should be considered experimental. List of exported C routines and their signatures are provided below in the usage section.\n}\n\\usage{\n# SEXP DT_subsetDT(SEXP x, SEXP rows, SEXP cols);\n# p_DT_subsetDT = R_GetCCallable(\"data.table\", \"DT_subsetDT\");\n}\n\\details{\n Details on how to use these can be found in the \\emph{Writing R Extensions} manual \\emph{Linking to native routines in other packages} section.\n An example use with \\code{Rcpp}:\n\\preformatted{\n dt = data.table::as.data.table(iris)\n Rcpp::cppFunction(\"SEXP mysub2(SEXP x, SEXP rows, SEXP cols) { return DT_subsetDT(x,rows,cols); }\",\n include=\"#include \",\n depends=\"data.table\")\n mysub2(dt, 1:4, 1:4)\n}\n}\n\\note{\n Be aware C routines are likely to have less input validation than their corresponding R interface. For example one should not expect \\code{DT[-5L]} will be equal to \\code{.Call(DT_subsetDT, DT, -5L, seq_along(DT))} because translation of \\code{i=-5L} to \\code{seq_len(nrow(DT))[-5L]} might be happening on R level. Moreover checks that \\code{i} argument is in range of \\code{1:nrow(DT)}, missingness, etc. might be happening on R level too.\n}\n\\references{\n \\url{https://cran.r-project.org/doc/manuals/r-release/R-exts.html}\n}\n\\keyword{ data }\n\n---\n\n## OK, je commence à comprendre ce qu'est data.table, mais pourquoi n'avez-vous pas simplement amélioré `data.frame` dans R ? Pourquoi faut-il que ce soit un nouveau package ?\n\nComme [souligné ci-dessus] (#j-num), `j` dans `[.data.table` est fondamentalement différent de `j` dans `[.data.frame`. Même si quelque chose d'aussi simple que `DF[ , 1]` était modifié dans la base R pour retourner un data.frame plutôt qu'un vecteur, cela casserait le code existant dans des milliers de package CRAN et dans le code utilisateur. Dès que nous avons pris la décision de créer une nouvelle classe héritant de data.frame, nous avons eu l'opportunité de changer certaines choses et nous l'avons fait. Nous voulons que data.table soit légèrement différent et qu'il fonctionne de cette façon pour que la syntaxe plus compliquée fonctionne. Il existe également d'autres différences (voir [ci-dessous](#PetitesDifférences) ).\n\nDe plus, data.table *hérite* de `data.frame`. C'est aussi un `data.frame`. Un data.table peut être passé à n'importe quel package qui n'accepte que `data.frame` et ce package peut utiliser la syntaxe `[.data.frame` sur le data.table. Voir [cette réponse] (https://stackoverflow.com/a/10529888/403310) pour savoir comment procéder.\n\nNous avons également proposé des améliorations à R chaque fois que cela était possible. L'une d'entre elles a été acceptée comme nouvelle fonctionnalité dans R 2.12.0 :\n\n> `unique()` et `match()` sont maintenant plus rapides sur les vecteurs de caractères où tous les éléments sont dans le cache global CHARSXP et ont un encodage non marqué (ASCII). Merci à Matt Dowle pour avoir suggéré des améliorations dans la façon dont le code de hachage est généré dans unique.c.\n\nUne deuxième proposition était d'utiliser `memcpy` dans duplicate.c, qui est beaucoup plus rapide qu'une boucle for en C. Cela améliorerait la *manière* dont R copie les données en interne (sur certaines mesures, de 13 fois). Le fil de discussion sur r-devel est [ici] (https://stat.ethz.ch/pipermail/r-devel/2010-April/057249.html).\n\nUne troisième proposition plus significative qui a été acceptée est que R utilise maintenant le code de tri par base (radix sort) de data.table à partir de R 3.3.0 :\n\n> L'algorithme de tri par base (radix sort) et l'implémentation de data.table (forder) remplace l'ancien tri par base (comptage) et ajoute une nouvelle méthode pour order(). Proposé par Matt Dowle et Arun Srinivasan, le nouvel algorithme supporte les vecteurs de logiques, d’entiers (même avec de grandes valeurs), de réels et de caractères. Il est plus performant que toutes les autres méthodes, mais il y a quelques mises en garde (voir ?sort).\n\nC'était un grand événement pour nous et nous l'avons fêté jusqu'à ce que les vaches rentrent à la maison. (Pas vraiment.)\n\n## Pourquoi les valeurs par défaut sont-elles telles qu'elles sont ? Pourquoi le système fonctionne-t-il comme il le fait ?\n\nLa réponse est simple : l'auteur principal l'a conçu à l'origine pour son propre usage. C'est ce qu'il voulait. Il trouve que c'est une façon plus naturelle et plus rapide d'écrire du code, qui s'exécute également plus rapidement.\n\n## N'est-ce pas déjà fait par `with()` et `subset()` dans `base` ?\n\nCertaines des caractéristiques discutées jusqu'à présent sont, oui. Le package s'appuie sur la fonctionnalité de base. Il fait le même genre de choses, mais avec moins de code et s'exécute beaucoup plus rapidement s'il est utilisé correctement.\n\n## Pourquoi `X[Y]` retourne-t-il aussi toutes les colonnes de `Y` ? Ne devrait-elle pas retourner un sous-ensemble de `X` ?\n\n---\n\n#### Blanket import\n\nAlternatively, you can import all functions from `data.table` at once, though this is generally not recommended:\n\n```r\nimport(data.table)\n```\n\n**Justification for Avoiding Blanket Imports:**\n1. **Documentation**: The NAMESPACE file can serve as good documentation of how you depend on certain packages.\n2. **Avoiding Conflicts**: Blanket imports leave you open to subtle breakage. For example, if you `import(pkgA)` and `import(pkgB)`, but later pkgB exports a function also exported by pkgA, this will break your package due to conflicts in your namespace, which is disallowed by `R CMD check` and CRAN.\n\n### Step 3: Update Your R code files outside the package's R/ directory\n\nWhen you move a package from `Depends` to `Imports`, it will no longer be automatically attached when your package is loaded. This can be important for examples, tests, vignettes, and demos, where `Imports` packages need to be attached explicitly.\n\n**Before (with `Depends`):**\n```r\n# data.table functions are directly available\nlibrary(MyPkgDependsDataTable)\ndt <- data.table(x = 1:10, y = letters[1:10])\nsetDT(dt)\nresult <- merge(dt, other_dt, by = \"x\")\n```\n\n**After (with `Imports`):**\n```r\n# Explicitly load data.table in user scripts or vignettes\nlibrary(data.table)\nlibrary(MyPkgDependsDataTable)\ndt <- data.table(x = 1:10, y = letters[1:10])\nsetDT(dt)\nresult <- merge(dt, other_dt, by = \"x\")\n```\n\n### Benefits of using `Imports`\n- **User-Friendliness**: `Depends` alters your users' `search()` path, possibly without their wanting to do so.\n- **Namespace Management**: Only the functions your package explicitly imports are available, reducing the risk of function name clashes.\n- **Cleaner Package Loading**: Your package's dependencies are not attached to the search path, making the loading process cleaner and potentially faster.\n- **Easier Maintenance**: It simplifies maintenance tasks as upstream dependencies' APIs evolve. Depending too much on `Depends` can lead to conflicts and compatibility issues over time.\n\n```{r, echo = FALSE, message = FALSE}\ndata.table::setDTthreads(.old.th)\n```\n\n---\n\n#ifdef ENABLE_NLS\n#include \n#define _(String) dgettext(\"data.table\", String)\n// NB: flip argument order to match that of R's ngettext()\n#define Pl_(n, String1, StringPlural) dngettext(\"data.table\", String1, StringPlural, n)\n#else\n#define _(String) (String)\n#define Pl_(n, String1, StringPlural) ((n) == 1 ? (String1) : (StringPlural))\n#endif\n\n---\n\nLe mécanisme des options dans R est *global*. Cela signifie que si un utilisateur définit une option `data.table` pour son propre usage, ce réglage affecte également le code de tout package qui utilise `data.table`. Pour une option comme `datable.verbose`, c'est exactement le comportement désiré puisque le but est de tracer et d'enregistrer toutes les opérations de `data.table` d'où qu'elles viennent ; activer la verbosité n'affecte pas les résultats. Une autre option unique à R et excellente pour la production est `options(warn=2)` qui transforme tous les avertissements en erreurs. Encore une fois, le but est d'affecter n'importe quel avertissement dans n'importe quel package afin de ne manquer aucun avertissement en production. Il y a 6 options `datable.print.*` et 3 options d'optimisation qui n'affectent pas le résultat des opérations. Cependant, il y a une option `data.table` qui l'affecte et qui est maintenant un problème : `datatable.nomatch`. Cette option change la jointure par défaut d'externe à interne. [A côté de cela, la jointure par défaut est externe parce que outer est plus sûr ; il ne laisse pas tomber les données manquantes silencieusement ; de plus, il est cohérent avec la façon dont la base R fait correspondre les noms et les indices]. Certains utilisateurs préfèrent que la jointure interne soit la valeur par défaut et nous avons prévu cette option pour eux. Cependant, un utilisateur qui met en place cette option peut involontairement changer le comportement des jointures à l'intérieur des packages qui utilisent `data.table`. En conséquence, dans la version 1.12.4 (Oct 2019), un message était affiché lorsque l'option `datable.nomatch` était utilisée, et à partir de la version 1.14.2, elle est maintenant ignorée avec un avertissement. C'était la seule option `datable.table` qui posait ce problème.\n\n## Dépannage\n\nSi vous rencontrez des problèmes lors de la création d'un package qui utilise data.table, veuillez confirmer que le problème est reproductible dans une session R propre en utilisant la console R : `R CMD check nom.package`.\n\nCertains des problèmes les plus courants auxquels les développeurs sont confrontés sont généralement liés à des outils d'aide destinés à automatiser certaines tâches de développement de package, par exemple, l'utilisation de `roxygen` pour générer votre fichier `NAMESPACE` à partir des métadonnées des fichiers de code R. D'autres sont liés aux outils d'aide qui construisent et vérifient les package. D'autres sont liées aux aides qui construisent et vérifient le package. Malheureusement, ces aides ont parfois des effets secondaires inattendus/cachés qui peuvent masquer la source de vos problèmes. Ainsi, assurez-vous de faire une double vérification en utilisant la console R (lancez R sur la ligne de commande) et assurez-vous que l'importation est définie dans les fichiers `DESCRIPTION` et `NAMESPACE` en suivant les [instructions](#DESCRIPTION) [ci-dessus](#NAMESPACE).\n\nSi vous n'êtes pas en mesure de reproduire les problèmes que vous rencontrez en utilisant la simple console R pour construire (\"build\") et vérifier (\"check\"), vous pouvez essayer d'obtenir de l'aide en vous basant sur les problèmes que nous avons rencontrés dans le passé avec `data.table` interagissant avec des outils d'aide : [devtools#192](https://github.com/r-lib/devtools/issues/192) ou [devtools#1472](https://github.com/r-lib/devtools/issues/1472).\n\n## Licence\n\nDepuis la version 1.10.5, `data.table` est sous licence Mozilla Public License (MPL). Les raisons du changement de la GPL peuvent être lues en entier [ici](https://github.com/Rdatatable/data.table/pull/2456) et vous pouvez en savoir plus sur la MPL sur Wikipedia [ici](https://en.wikipedia.org/wiki/Mozilla_Public_License) et [ici](https://en.wikipedia.org/wiki/Comparison_of_free_and_open-source_software_licenses).\n\n## Importe optionnellement `data.table` : `Suggests`\n\n---\n\nUsing ggplot2 Inside data.table John Lashlee 2019.10 Fast and Readable 'If Else' in R Tysson Barrett 2019.10 Data Joins: Speed and Efficiency of dplyr and data.table Tysson Barrett 2019.10 Comparing Efficiency and Speed of data.table : Adding variables, filtering rows, and summarizing by group Tysson Barrett 2019.10 Columnar File Performance Check-in for Python and R: Parquet, Feather, and FST Wes McKinney 2019.09 Selecting the max value from each group, a case study: data.table Nathan Eastwood 2019.09 Sentiment analysis at the Fringe, part 1 Megan Stodel 2019.09 {disk.frame} is epic Bruno Rodrigues 2019.08 A shallow benchmark of R data frame export/import methods Julien Barnier 2019.08 The R Factor Owen Jones 2019.08 Hydra Chronicles, Part V: Loose Ends Brodie Gaslam 2019.08 Everyone’s Favorite Blogpost: CSV Benchmarks Jacob Quinn 2019.08 No visible binding for global variable Nathan Eastwood 2019.08 Why Machine Learning is more Practical than Econometrics in the Real World Adrian Antico 2019.08 What’s next for the popular programming language R? Dan Kopf 2019.08 Wrangling 4.6M Rows with dtplyr (the NEW data.table backend for dplyr) Matt Dancho 2019.08 mlr3-0.1.0 Patrick Schratz 2019.07 Hydra Chronicles, Part IV: Reformulation of Statistics Brodie Gaslam 2019.07 Multiple Columns to Multiple Colums at Once Recle Etino Vibal 2019.07 Long to Wide and Wide to Long Format Conversion Giovanni Pavolini 2019.07 fread-benchmarks-rsuite Alfonso R. Reyes 2019.07 Bayesian Power Analysis with data.table , tidyverse , and brms Tyson Barrett 2019.07 Making .SD your best friend José Morales 2019.07 data.table's cube function Giovanni Pavolini 2019.07 How to use .SD in the data.table package Sharon Machlis 2019.07 Why I Chose to Learn data.table (and such related things) Tyson Barrett 2019.07 What R’s most popular tools say about the state of data science Dan Kopf 2019.07 data.table and Text Analysis: Analyzing the Four Gospels Tyson Barrett 2019.07 Analyzing data with data.table Giovanni Pavolini 2019.07 Why I love data.table Elio Campitelli 2019.07 Why I like the Tidyverse Chris Muir 2019.07 An opinionated view of the Tidyverse \"dialect\" of the R language, and its promotion by RStudio Circa this revision on GitHub was in effect at the time and widely shared; e.g. HackerNews . Revision announced 2022.04 . Norm Matloff 2019.06 Learning Japanese with data.table and ggplot2 Atrebas 2019.06 data.table by a dummy John MacKintosh 2019.06 My Favorite data.table Feature John Mount 2019.06 Coke vs. Pepsi? data.table vs. tidy? Part 2) Beth Milhollin, Russell Zaretzki, and Audris Mockus 2019.06 The Psychology of Flame Wars Edwin Thoen 2019.06 data.table is Much Better Than You Have Been Told John Mount 2019.06 data.table is expressive and powerful Michael Frasco 2019.06 How data.table's fread can save you a lot of time and memory, and take input from shell commands Jozef Hajnala 2019.06 Hydra Chronicles, part III: Catastrophic Imprecision Brodie Gaslam 2019.06 Hydra Chronicles, part II: beating data.table at its own game Brodie Gaslam 2019.06 An Overview of Python's Datatable package Parul Pandey 2019.06 For and Against data.table Aaron Jacobs 2019.05 Three reasons why I use data.table Megan Stodel 2019.05 Timing Working With a Row or a Column from a data.frame John Mount 2019.05 Using Data Cubes with R Kristian Larsen 2019.05 cranlogs 2.1.1 is on CRAN! R-hub blog 2019.05 R package installation on windows considered harmful Toby Dylan Hocking 2019.05 Hydra Chronicles, part I: Pixie Dust Brodie Gaslam 2019.04 Using data.table with magrittr pipes: best of both worlds Martin Chan 2019.04 What are the Popular R Packages? John Mount 2019.04 Coke vs. Pepsi? data.table vs. tidy? Examining Consumption Preferences for Data Scientists Audris Mockus 2019.03 A data.table and dplyr tour Atrebas 2019.03 Dependencies. Now with badges! Dirk Eddelbuettel 2019.03 Unit Tests in R John Mount 2019.03 Creating blazing fast pivot tables from R with data.table - now with\n\n---\n\n#: data.table.R:139\n#, c-format\nmsgid \"Item '%s' not found in names of input list\"\nmsgstr \"Élément '%s' non trouvé parmi les noms de la liste d'entrée\"\n\n#: data.table.R:159\n#, c-format\nmsgid \"\"\n\"[ was called on a data.table in an environment that is not data.table-aware \"\n\"(i.e. cedta()), but '%s' was used, implying the owner of this call really \"\n\"intended for data.table methods to be called. See vignette('datatable-\"\n\"importing') for details on properly importing data.table.\"\nmsgstr \"\"\n\"[ a été appelé sur un data.table dans un environnement qui n'est pas \"\n\"compatible avec data.table (i.e. cedta()), mais '%s' a été utilisé, ce qui \"\n\"implique que le propriétaire de cet appel avait vraiment l'intention \"\n\"d'appeler des méthodes data.table. Voir la vignette('datatable-importing') \"\n\"pour plus de détails sur l’importation correcte de data.table.\"\n\n#: data.table.R:170\n#, c-format\nmsgid \"verbose must be logical or integer\"\nmsgstr \"verbose doit être soit un booléen, soit un entier\"\n\n#: data.table.R:171\n#, c-format\nmsgid \"verbose must be length 1 non-NA\"\nmsgstr \"verbose doit être de longueur 1 et différent de NA\"\n\n#: data.table.R:179\n#, c-format\nmsgid \"Ignoring by/keyby because 'j' is not supplied\"\nmsgstr \"L'argument by ou keyby est ignoré car 'j' n'est pas fourni\"\n\n#: data.table.R:193\n#, c-format\nmsgid \"When by and keyby are both provided, keyby must be TRUE or FALSE\"\nmsgstr \"\"\n\"Si by et keyby sont fournis simultanément, keyby doit être TRUE ou FALSE\"\n\n#: data.table.R:196 data.table.R:261 data.table.R:351\nmsgid \"Argument '%s' after substitute: %s\"\nmsgstr \"Argument '%s' après substitution : %s\"\n\n#: data.table.R:205\n#, c-format\nmsgid \"\"\n\"When on= is provided but not i=, on= must be a named list or data.table|\"\n\"frame, and a natural join (i.e. join on common names) is invoked. Ignoring \"\n\"on= which is '%s'.\"\nmsgstr \"\"\n\"Lorsque on= est fourni mais pas i=, on= doit être une liste nommée ou un \"\n\"data.table|frame, et une jointure naturelle (c'est-à-dire une jointure sur \"\n\"les noms communs) est invoquée. La valeur de on= qui est '%s' est ignorée.\"\n\n#: data.table.R:218\n#, c-format\nmsgid \"\"\n\"i and j are both missing so ignoring the other arguments. This warning will \"\n\"be upgraded to error in future.\"\nmsgstr \"\"\n\"i et j sont tous les deux absents, donc les autres arguments sont ignorés. \"\n\"Cet avertissement deviendra une erreur à l'avenir.\"\n\n#: data.table.R:222\n#, c-format\nmsgid \"mult argument can only be 'first', 'last', 'all' or 'error'\"\nmsgstr \"l'argument mult ne peut valoir que 'first', 'last', 'all' ou 'error'\"\n\n#: data.table.R:224\n#, c-format\nmsgid \"\"\n\"roll must be a single TRUE, FALSE, positive/negative integer/double \"\n\"including +Inf and -Inf or 'nearest'\"\nmsgstr \"\"\n\"roll doit être une seule valeur TRUE, FALSE, un entier ou un double, positif \"\n\"ou négatif, +Inf, -Inf ou 'nearest' compris\"\n\n#: data.table.R:226\n#, c-format\nmsgid \"roll is '%s' (type character). Only valid character value is 'nearest'.\"\nmsgstr \"\"\n\"roll vaut '%s' (de type caractère). La seule chaîne valide est 'nearest'.\"\n\n#: data.table.R:231\n#, c-format\nmsgid \"rollends must be a logical vector\"\nmsgstr \"rollends doit être un vecteur de booléens\"\n\n#: data.table.R:232\n#, c-format\nmsgid \"rollends must be length 1 or 2\"\nmsgstr \"rollends doit être de longueur 1 ou 2\"\n\n#: data.table.R:240\n#, c-format\nmsgid \"\"\n\"nomatch= must be either NA or NULL (or 0 for backwards compatibility which \"\n\"is the same as NULL but please use NULL)\"\nmsgstr \"\"\n\"nomatch= doit valoir soit NA, soit NULL (ou 0 pour la compatibilité arrière \"\n\"qui équivaut à NULL, mais utiliser NULL dorénavant)\"\n\n#: data.table.R:243\n#, c-format\nmsgid \"which= must be a logical vector length 1. Either FALSE, TRUE or NA.\"\nmsgstr \"\"\n\"which= doit être un vecteur de booléens de longueur 1. Valeur FALSE, TRUE ou \"\n\"NA.\"\n\n---\n\n3. `print` method for `data.table` gains `trunc.cols` argument (and corresponding option `datatable.print.trunc.cols`, default `FALSE`), [#1497](https://github.com/Rdatatable/data.table/issues/1497), part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). This prints only as many columns as fit in the console without wrapping to new lines (e.g., the first 5 of 80 columns) and a message that states the count and names of the variables not shown. When `class=TRUE` the message also contains the classes of the variables. `data.table` has always automatically truncated _rows_ of a table for efficiency (e.g. printing 10 rows instead of 10 million); in the future, we may do the same for _columns_ (e.g., 10 columns instead of 20,000) by changing the default for this argument. Thanks to @nverno for the initial suggestion and to @TysonStanley for the PR.\n\n4. `setnames(DT, new=new_names)` (i.e. explicitly named `new=` argument) now works as expected rather than an error message requesting that `old=` be supplied too, [#4041](https://github.com/Rdatatable/data.table/issues/4041). Thanks @Kodiologist for the suggestion.\n\n5. `nafill` and `setnafill` gain `nan` argument to say whether `NaN` should be considered the same as `NA` for filling purposes, [#4020](https://github.com/Rdatatable/data.table/issues/4020). Prior versions had an implicit value of `nan=NaN`; the default is now `nan=NA`, i.e., `NaN` is treated as if it's missing. Thanks @AnonymousBoba for the suggestion. Also, while `nafill` still respects `getOption('datatable.verbose')`, the `verbose` argument has been removed.\n\n6. New function `fcase(...,default)` implemented in C by Morgan Jacob, [#3823](https://github.com/Rdatatable/data.table/issues/3823), is inspired by SQL `CASE WHEN` which is a common tool in SQL for e.g. building labels or cutting age groups based on conditions. `fcase` is comparable to R function `dplyr::case_when` however it evaluates its arguments in a lazy way (i.e. only when needed) as shown below. Please see `?fcase` for more details.\n\n ```R\n # Lazy evaluation\n x = 1:10\n data.table::fcase(\n\t x < 5L, 1L,\n\t x >= 5L, 3L,\n\t x == 5L, stop(\"provided value is an unexpected one!\")\n )\n # [1] 1 1 1 1 3 3 3 3 3 3\n\n dplyr::case_when(\n\t x < 5L ~ 1L,\n\t x >= 5L ~ 3L,\n\t x == 5L ~ stop(\"provided value is an unexpected one!\")\n )\n # Error in eval_tidy(pair$rhs, env = default_env) :\n # provided value is an unexpected one!\n\n # Benchmark\n x = sample(1:100, 3e7, replace = TRUE) # 114 MB\n microbenchmark::microbenchmark(\n dplyr::case_when(\n x < 10L ~ 0L,\n x < 20L ~ 10L,\n x < 30L ~ 20L,\n x < 40L ~ 30L,\n x < 50L ~ 40L,\n x < 60L ~ 50L,\n x > 60L ~ 60L\n ),\n data.table::fcase(\n x < 10L, 0L,\n x < 20L, 10L,\n x < 30L, 20L,\n x < 40L, 30L,\n x < 50L, 40L,\n x < 60L, 50L,\n x > 60L, 60L\n ),\n times = 5L,\n unit = \"s\")\n # Unit: seconds\n # expr min lq mean median uq max neval\n # dplyr::case_when 11.57 11.71 12.22 11.82 12.00 14.02 5\n # data.table::fcase 1.49 1.55 1.67 1.71 1.73 1.86 5\n ```\n\n7. `.SDcols=is.numeric` now works; i.e., `SDcols=` accepts a function which is used to select the columns of `.SD`, [#3950](https://github.com/Rdatatable/data.table/issues/3950). Any function (even _ad hoc_) that returns scalar `TRUE`/`FALSE` for each column will do; e.g., `.SDcols=!is.character` will return _non_-character columns (_a la_ `Negate()`). Note that `.SDcols=patterns(...)` can still be used for filtering based on the column names.\n\n---\n\n9. `isoweek()` is much faster (e.g. 20x) by re-using an implementation from {base}, [#5111](https://github.com/Rdatatable/data.table/issues/5111). Thanks @MichaelChirico for the report and PR.\n\n10. `data.table()` and `as.data.table()` with `keep.rownames=TRUE` now extract row names from named vectors, matching `data.frame()` behavior. Names from the first named vector in the input are used to create the row names column (default name `\"rn\"` or custom name via `keep.rownames=\"column_name\"`), [#1916](https://github.com/Rdatatable/data.table/issues/1916). Thanks to @richierocks for the feature request and @Mukulyadav2004 for the implementation.\n\n11. New `frev(x)` as a faster analogue to `base::rev()` for atomic vectors/lists, [#5885](https://github.com/Rdatatable/data.table/issues/5885). Twice as fast as `base::rev()` on large inputs, and faster with more threads. Thanks to Benjamin Schwendinger for suggesting and implementing.\n\n12. New `cbindlist()` and `setcbindlist()` for concatenating a `list` of data.tables column-wise, evocative of the analogous `do.call(rbind, l)` <-> `rbindlist(l)`, [#2576](https://github.com/Rdatatable/data.table/issues/2576). `setcbindlist()` does so without making any copies. Thanks @MichaelChirico for the FR, @jangorecki for the PR, and @MichaelChirico for extensive reviews and fine-tuning.\n\n ```r\n l = list(\n data.table(id = 1:3, a = letters[1:3]),\n data.table(b = 4:6, c = 7:9)\n )\n cbindlist(l)\n # id a b c\n # 1: 1 a 4 7\n # 2: 2 b 5 8\n # 3: 3 c 6 9\n ```\n\n13. New `mergelist()` and `setmergelist()` similarly work _a la_ `Reduce()` to recursively merge a `list` of data.tables, [#599](https://github.com/Rdatatable/data.table/issues/599). Different join modes (_left_, _inner_, _full_, _right_, _semi_, _anti_, and _cross_) are supported through the `how` argument; duplicate handling goes through the `mult` argument. `setmergelist()` carefully avoids copies where one is not needed, e.g. in a 1:1 left join. Thanks Patrick Nicholson for the FR (in 2013!), @jangorecki for the PR, and @MichaelChirico for extensive reviews and fine-tuning.\n\n ```r\n l = list(\n data.table(id = c(1L, 2L, 3L), x = c(\"a\", \"b\", \"c\")),\n data.table(id = c(1L, 2L, 4L), y = c(\"d\", \"e\", \"f\")),\n data.table(id = c(1L, 3L, 4L), z = c(\"g\", \"h\", \"i\"))\n )\n\n # Recursive inner join\n mergelist(l, on = \"id\", how = \"inner\")\n # id x y z\n # 1: 1 a d g\n\n # Recursive left join (the default 'how')\n mergelist(l, on = \"id\", how = \"left\")\n # id x y z\n # 1: 1 a d g\n # 2: 2 b e \n # 3: 3 c h\n ```\n\n14. `fcoalesce()` and `setcoalesce()` gain `nan` argument to control whether `NaN` values should be treated as missing (`nan=NA`, the default) or non-missing (`nan=NaN`), [#4567](https://github.com/Rdatatable/data.table/issues/4567). This provides full compatibility with `nafill()` behavior. Thanks to @ethanbsmith for the feature request and @Mukulyadav2004 for the implementation.\n\n15. New function `isoyear()` has been implemented as a complement to `isoweek()`, returning the ISO 8601 year corresponding to a given date, [#7154](https://github.com/Rdatatable/data.table/issues/7154). Thanks to @ben-schwen and @MichaelChirico for the suggestion and @venom1204 for the implementation.\n\n---\n\n```{r}\nDT = data.table(\n ID = c(\"b\",\"b\",\"b\",\"a\",\"a\",\"c\"),\n a = 1:6,\n b = 7:12,\n c = 13:18\n)\nDT\nclass(DT$ID)\n```\n\nVous pouvez aussi convertir des objets existants en une `data.table` en utilisant `setDT()` (pour les structures `data.frame` et `list`) ou `as.data.table()` (pour les autres structures). Pour les autres détails concernant les différences (ce qui est hors du champ de cette vignette), voir `?setDT` et `?as.data.table`.\n\n#### Notez que :\n\n* Les numéros de ligne sont imprimés avec un `:` afin de séparer visuellement le numéro de ligne de la première colonne.\n\n* Lorsque le nombre de lignes à imprimer dépasse l'option globale `datatable.print.nrows` (défaut = `r getOption(\"datatable.print.nrows\")`), il n'imprime automatiquement que les 5 premières et les 5 dernières lignes (comme on peut le voir dans la section [Data](#data)). Pour un grand `data.frame`, vous avez pu vous retrouver à attendre que des tables plus grandes s'impriment et se mettent en page, parfois sans fin. Cette restriction permet d'y remédier, et vous pouvez demander le nombre par défaut de la façon suivante : \n\n ```{.r}\n getOption(\"datatable.print.nrows\")\n ```\n\n* `data.table` ne définit ni n'utilise jamais de *nom de ligne*. Nous verrons pourquoi dans la [`vignette(\"datatable-keys-fast-subset\", package=\"data.table\")`](datatable-keys-fast-subset.html).\n\n### b) Forme générale - dans quel sens la 'data.table' est-elle *étendue* ? {#enhanced-1b}\n\nPar rapport à un `data.frame`, vous pouvez faire *beaucoup plus de choses* qu'extraire des lignes et sélectionner des colonnes dans la structure d'une `data.table`, par exemple, avec `[ ... ]` (Notez bien : nous pourrions aussi faire référence à écrire quelque chose dans `DT[...]` comme \"interroger `DT`\", par analogie ou similairement à SQL). Pour le comprendre il faut d'abord que nous regardions la *forme générale* de la syntaxe `data.table`, comme indiqué ci-dessous :\n\n```r\nDT[i, j, by]\n\n## R: i j by\n## SQL: where | order by select | update group by\n```\n\nLes utilisateurs ayant des connaissances SQL feront peut être directement le lien avec cette syntaxe.\n\n#### La manière de le lire (à haute voix) est :\n\nUtiliser `DT`, extraire ou trier les lignes en utilisant `i`, puis calculer `j`, grouper avec `by`.\n\nCommençons par voir 'i' et 'j' d'abord - en indiçant les lignes et en travaillant sur les colonnes.\n\n### c) Regrouper les lignes en 'i' {#subset-i-1c}\n\n#### -- Obtenir tous les vols qui ont \"JFK\" comme aéroport de départ pendant le mois de juin.\n\n```{r}\nans <- flights[origin == \"JFK\" & month == 6L]\nhead(ans)\n```\n\n* Dans le cadre d'un `data.table`, on peut se référer aux colonnes *comme s'il s'agissait de variables*, un peu comme dans SQL ou Stata. Par conséquent, nous nous référons simplement à `origin` et `month` comme s'il s'agissait de variables. Nous n'avons pas besoin d'ajouter le préfixe `vol$` à chaque fois. Néanmoins, l'utilisation de `flights$origin` et `flights$month` fonctionnerait parfaitement.\n\n* Les *indices de ligne* qui satisfont la condition `origin == \"JFK\" & month == 6L` sont calculés, et puisqu'il n'y a rien d'autre à faire, toutes les colonnes de `flights` aux lignes correspondant à ces *indices de ligne* sont simplement renvoyées sous forme d’un `data.table`.\n\n* Une virgule après la condition dans `i` n'est pas nécessaire. Mais `flights[origin == \"JFK\" & month == 6L, ]` fonctionnerait parfaitement. Avec un `data.frame`, cependant, la virgule est indispensable.\n\n#### -- Récupérer les deux premières lignes de `flights`. {#subset-rows-integer}\n\n```{r}\nans <- flights[1:2]\nans\n```\n\n* Dans ce cas, il n'y a pas de condition. Les indices des lignes sont déjà fournis dans `i`. Nous retournons donc un `data.table` avec toutes les colonnes de `flights` aux lignes pour ces *index de ligne*.\n\n#### -- Trier `flights` d'abord sur la colonne `origin` dans l'ordre *ascending*, puis par `dest` dans l'ordre *descendant* :\n\n---\n\n(b) The functional form\n\n```r\nDT[, `:=`(colA = valA, # valA is assigned to colA\n colB = valB, # valB is assigned to colB\n ...\n)]\n```\n\nNote that the code above explains how `:=` can be used. They are not working examples. We will start using them on `flights` *data.table* from the next section.\n\n#\n\n* In (a), `LHS` takes a character vector of column names and `RHS` a *list of values*. `RHS` just needs to be a `list`, irrespective of how its generated (e.g., using `lapply()`, `list()`, `mget()`, `mapply()` etc.). This form is usually easy to program with and is particularly useful when you don't know the columns to assign values to in advance.\n\n* On the other hand, (b) is handy if you would like to jot some comments down for later.\n\n* The result is returned *invisibly*.\n\n* Since `:=` is available in `j`, we can combine it with `i` and `by` operations just like the aggregation operations we saw in the previous vignette.\n\n#\n\nIn the two forms of `:=` shown above, note that we don't assign the result back to a variable. Because we don't need to. The input *data.table* is modified by reference. Let's go through examples to understand what we mean by this.\n\nFor the rest of the vignette, we will work with `flights` *data.table*.\n\n## 2. Add/update/delete columns *by reference*\n\n### a) Add columns by reference {#ref-j}\n\n#### -- How can we add columns *speed* and *total delay* of each flight to `flights` *data.table*?\n\n```{r}\nflights[, `:=`(speed = distance / (air_time/60), # speed in mph (mi/h)\n delay = arr_delay + dep_delay)] # delay in minutes\nhead(flights)\n\n## alternatively, using the 'LHS := RHS' form\n# flights[, c(\"speed\", \"delay\") := list(distance/(air_time/60), arr_delay + dep_delay)]\n```\n\n#### Note that\n\n* We did not have to assign the result back to `flights`.\n\n* The `flights` *data.table* now contains the two newly added columns. This is what we mean by *added by reference*.\n\n* We used the functional form so that we could add comments on the side to explain what the computation does. You can also see the `LHS := RHS` form (commented).\n\n### b) Update some rows of columns by reference - *sub-assign* by reference {#ref-i-j}\n\nLet's take a look at all the `hours` available in the `flights` *data.table*:\n\n```{r}\n# get all 'hours' in flights\nflights[, sort(unique(hour))]\n```\n\nWe see that there are totally `25` unique values in the data. Both *0* and *24* hours seem to be present. Let's go ahead and replace *24* with *0*.\n\n#### -- Replace those rows where `hour == 24` with the value `0`\n\n```{r}\n# subassign by reference\nflights[hour == 24L, hour := 0L]\n```\n\n* We can use `i` along with `:=` in `j` the very same way as we have already seen in the [`vignette(\"datatable-intro\", package=\"data.table\")`](datatable-intro.html) vignette.\n\n* Column `hour` is replaced with `0` only on those *row indices* where the condition `hour == 24L` specified in `i` evaluates to `TRUE`.\n\n* `:=` returns the result invisibly. Sometimes it might be necessary to see the result after the assignment. We can accomplish that by adding an empty `[]` at the end of the query as shown below:\n\n ```{r}\n flights[hour == 24L, hour := 0L][]\n ```\n\n#\nLet's look at all the `hours` to verify.\n\n```{r}\n# check again for '24'\nflights[, sort(unique(hour))]\n```\n\n#### Exercise: {#update-by-reference-question}\n\nWhat is the difference between `flights[hour == 24L, hour := 0L]` and `flights[hour == 24L][, hour := 0L]`? Hint: The latter needs an assignment (`<-`) if you would want to use the result later.\n\nIf you can't figure it out, have a look at the `Note` section of `?\":=\"`.\n\n### c) Delete column by reference\n\n#### -- Remove `delay` column\n\n```{r}\nflights[, c(\"delay\") := NULL]\nhead(flights)\n\n## or using the functional form\n# flights[, `:=`(delay = NULL)]\n```\n\n#### {#delete-convenience}\n\n* Assigning `NULL` to a column *deletes* that column. And it happens *instantly*.\n\n---\n\n\\code{IDateTime} takes a date-time input and returns a data table with\ncolumns \\code{date} and \\code{time}.\n\nUsing integer storage allows dates and/or times to be used as data table\nkeys. With positive integers with a range less than 100,000, grouping\nand sorting is fast because radix sorting can be used (see\n\\code{sort.list}).\n\nSeveral convenience functions like \\code{hour} and \\code{quarter} are\nprovided to group or extract by hour, month, and other date-time\nintervals. \\code{as.POSIXlt} is also useful. For example,\n\\code{as.POSIXlt(x)$mon} is the integer month. The R base convenience\nfunctions \\code{weekdays}, \\code{months}, and \\code{quarters} can also\nbe used, but these return character values, so they must be converted to\nfactors for use with data.table. \\code{isoweek} is ISO 8601-consistent.\n\nThe \\code{round} method for IDate's is useful for grouping and plotting.\nIt can round to weeks, months, quarters, and years. Similarly, the \\code{round}\nand \\code{trunc} methods for ITime's are useful for grouping and plotting.\nThey can round or truncate to hours and minutes.\nNote for ITime's with 30 seconds, rounding is inconsistent due to rounding off a 5.\nSee 'Details' in \\code{\\link{round}} for more information.\n\nFunctions like \\code{week()} and \\code{isoweek()} provide week numbering functionality.\n\\code{week()} computes completed or fractional weeks within the year,\nwhile \\code{isoweek()} calculates week numbers according to ISO 8601 standards,\nwhich specify that the first week of the year is the one containing the first Thursday.\nThis convention ensures that week boundaries align consistently with year boundaries,\naccounting for both year transitions and varying day counts per week.\n\nSimilarly, \\code{isoyear()} returns the ISO 8601 year corresponding to the ISO week.\n\n}\n\n\\value{\n For \\code{as.IDate}, a class of \\code{IDate} and \\code{Date} with the\n date stored as the number of days since some origin.\n\n For \\code{as.ITime}, a class of \\code{ITime}\n stored as the number of seconds in the day.\n\n For \\code{IDateTime}, a data table with columns \\code{idate} and\n \\code{itime} in \\code{IDate} and \\code{ITime} format.\n\n \\code{second}, \\code{minute}, \\code{hour}, \\code{yday}, \\code{wday},\n \\code{mday}, \\code{week}, \\code{isoweek}, \\code{isoyear}, \\code{month}, \\code{quarter},\n and \\code{year} return integer values\n for second, minute, hour, day of year, day of week,\n day of month, week, month, quarter, and year, respectively.\n \\code{yearmon} and \\code{yearqtr} return double values representing\n respectively \\code{year + (month-1) / 12} and \\code{year + (quarter-1) / 4}.\n\n \\code{second}, \\code{minute}, \\code{hour} are taken directly from\n the \\code{POSIXlt} representation.\n All other values are computed from the underlying integer representation\n and comparable with the values of their \\code{POSIXlt} representation\n of \\code{x}, with the notable difference that while \\code{yday}, \\code{wday},\n and \\code{mon} are all 0-based, here they are 1-based.\n\n}\n\\references{\n\n G. Grothendieck and T. Petzoldt, \\dQuote{Date and Time Classes in R},\n R News, vol. 4, no. 1, June 2004.\n\n H. Wickham, https://gist.github.com/hadley/10238.\n\n ISO 8601, https://www.iso.org/iso/home/standards/iso8601.htm\n}\n\n\\author{ Tom Short, t.short@ieee.org }\n\n\\seealso{ \\code{\\link{as.Date}}, \\code{\\link{as.POSIXct}},\n \\code{\\link{strptime}}, \\code{\\link{DateTimeClasses}}\n\n}\n\n\\examples{\n\n# create IDate:\n(d <- as.IDate(\"2001-01-01\"))\n\n# S4 coercion also works\nidentical(as.IDate(\"2001-01-01\"), methods::as(\"2001-01-01\", \"IDate\"))\n\n# create ITime:\n(t <- as.ITime(\"10:45\"))\n\n# S4 coercion also works\nidentical(as.ITime(\"10:45\"), methods::as(\"10:45\", \"ITime\"))\n\n(t <- as.ITime(\"10:45:04\"))\n\n(t <- as.ITime(\"10:45:04\", format = \"\\%H:\\%M:\\%S\"))\n\n# \"24:00:00\" is parsed as \"00:00:00\"\nas.ITime(\"24:00:00\")\n\n# Workaround for end-of-day: add 1 second to \"23:59:59\"\nas.ITime(\"23:59:59\") + 1L\n\nas.POSIXct(\"2001-01-01\") + as.ITime(\"10:45\")\n\n---\n\nEn este caso, la función no exportada `[.data.table` volverá a llamar a `[.data.frame` como medida de protección, ya que `data.table` no tiene forma de saber que el paquete padre es consciente de que está intentando realizar llamadas contra la sintaxis de la API de consulta de `data.table` (lo que podría generar un comportamiento inesperado ya que la estructura de las llamadas a `[.data.frame` y `[.data.table` difieren fundamentalmente, por ejemplo, este último tiene muchos más argumentos).\n\nSi este es su enfoque preferido para el desarrollo de paquetes, defina `.datatable.aware = TRUE` en cualquier parte de su código fuente de R (no es necesario exportar). Esto indica a `data.table` que usted, como desarrollador de paquetes, ha diseñado su código para que utilice intencionalmente su funcionalidad, aunque no sea evidente al inspeccionar su archivo `NAMESPACE`.\n\n`data.table` determina sobre la marcha si la función que llama es consciente de que está accediendo a `data.table` con la función interna `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), que, además de verificar `?getNamespaceImports` para su paquete, también verifica la existencia de esta variable (entre otras cosas).\n\n## Más información sobre las dependencias\n\nPara obtener documentación más canónica sobre la definición de dependencia de paquetes, consulte el manual oficial: [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html).\n\n## Importación de rutinas data.table C\n\nAlgunas de las rutinas C utilizadas internamente ahora se exportan a nivel C, por lo que se pueden usar en paquetes R directamente desde su código C. Consulte [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) para obtener detalles y la sección [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) *Enlace a rutinas nativas en otros paquetes* para su uso.\n\n## Importación desde aplicaciones que no son r {#non-r-api}\n\nAlgunas pequeñas partes del código C de `data.table` se aislaron de la API de RC y ahora pueden usarse desde aplicaciones que no sean de R mediante enlaces a archivos .so o .dll. Más adelante se proporcionarán detalles más concretos al respecto; por ahora, puede estudiar el código C aislado de la API de RC en [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) y [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c).\n\n## Cómo convertir su dependencia Depends en data.table a Imports\n\nPara convertir una dependencia `Depends` de `data.table` en una dependencia `Imports` en su paquete, siga estos pasos:\n\n### Paso 0. Asegúrese de que su paquete pase la verificación R CMD inicialmente\n\n### Paso 1. Actualice el archivo DESCRIPTION para colocar data.table en Imports, no en Depends\n\n**Antes:**\n\n```dcf\nDepends:\n R (>= 3.5.0),\n data.table\nImports:\n```\n\n**Después:**\n\n```dcf\nDepends:\n R (>= 3.5.0)\nImports:\n data.table\n```\n\n### Paso 2.1: Ejecutar `R CMD check`\n\nEjecute `R CMD check` para identificar importaciones o símbolos faltantes. Este paso ayuda a:\n\n- Detecta automáticamente cualquier función o símbolo de `data.table` que no se importe explícitamente.\n- Marca los símbolos especiales faltantes como `.N`, `.SD` y `:=`.\n- Proporciona retroalimentación inmediata sobre lo que se debe agregar al archivo NAMESPACE.\n\nNota: No todos estos usos son detectados por `R CMD check`. En particular, `R CMD check` omite algunos símbolos/funciones en fórmulas y no detecta expresiones analizadas como `parse(text = \"data.table(a = 1)\")`. Los paquetes necesitarán una buena cobertura de pruebas para detectar estos casos extremos.\n\n### Paso 2.2: Modificar el archivo NAMESPACE\n\nSegún los resultados de `R CMD check`, asegúrese de que se importen todas las funciones utilizadas, los símbolos especiales, los genéricos S3 y las clases S4 de `data.table`.\n\n---\n\nrequire(methods)\nif (exists(\"test.data.table\", .GlobalEnv, inherits=FALSE)) {\n if ((tt<-compiler::enableJIT(-1))>0)\n cat(\"This is dev mode and JIT is enabled (level \", tt, \") so there will be a brief pause around the first test.\\n\", sep=\"\")\n} else {\n require(data.table)\n test = data.table:::test\n INT = data.table:::INT\n colnamesInt = data.table:::colnamesInt\n coerceAs = data.table:::coerceAs\n}\n\nsugg = c(\n \"bit64\"\n)\nfor (s in sugg) {\n assign(paste0(\"test_\",s), loaded<-suppressWarnings(suppressMessages(\n library(s, character.only=TRUE, logical.return=TRUE, quietly=TRUE, warn.conflicts=FALSE, pos=\"package:base\") # attach at the end for #5101\n )))\n if (!loaded) cat(\"\\n**** Suggested package\",s,\"is not installed or has dependencies missing. Tests using it will be skipped.\\n\\n\")\n}\n\n---\n\n14. Passing functions programmatically with `env=` doesn't produce an opaque error, e.g. `DT[, f(b), env = list(f=sum)]`, [#6026](https://github.com/Rdatatable/data.table/issues/6026). Note that it's much better to pass functions like `f=\"sum\"` instead. Thanks to @MichaelChirico for the bug report and fix.\n\n### NOTES\n\n1. `transform()` method for data.table sped up substantially when creating new columns on large tables. Thanks to @OfekShilon for the report and PR. The implemented solution was proposed by @ColeMiller1.\n\n2. The documentation for the `fill` argument in `rbind()` and `rbindlist()` now notes the expected behaviour for missing `list` columns when `fill=TRUE`, namely to use `NULL` (not `NA`), [#4198](https://github.com/Rdatatable/data.table/pull/4198). Thanks @sritchie73 for the proposal and fix.\n\n3. data.table now depends on R 3.3.0 (2016) instead of 3.1.0 (2014). Recent versions of R have good features that we would gradually like to incorporate, and we see next to no usage of these very old versions of R. We originally attempted to bump only to R 3.2.0 in this release, but our vignette engine {knitr} requiring 3.3.0 and `R CMD check` lacking an `--ignore-vignettes` option until 3.3.0 essentially forced our hands.\n\n4. Erroneous assignment calls in `[` with a trailing comma (e.g. ``DT[, `:=`(a = 1, b = 2,)]``) get a friendlier error since this situation is common during refactoring and easy to miss visually. Thanks @MichaelChirico for the fix.\n\n5. Input files are now kept open during `mmap()` when running under Emscripten, [emscripten-core/emscripten#20459](https://github.com/emscripten-core/emscripten/issues/20459). This avoids an error in `fread()` when running in WebAssembly, [#5969](https://github.com/Rdatatable/data.table/issues/5969). Thanks to @maek-ies for the report and @georgestagg for the PR.\n\n6. `dcast()` improves behavior for the situation that the `fun.aggregate` value of `length()` is used but not provided by the user.\n\n a. This now triggers a warning, not a message, since relying on this default often signals unexpected duplicates in the data, [#5386](https://github.com/Rdatatable/data.table/issues/5386). The warning is classed as `dt_missing_fun_aggregate_warning`, allowing for more targeted handling in user code. Thanks @MichaelChirico for the suggestion and @Nj221102 for the fix.\n\n b. The warning itself does better explaining the behavior and suggesting alternatives, [#5217](https://github.com/Rdatatable/data.table/issues/5217). Thanks @MichaelChirico for the suggestion and @Nj221102 for the fix.\n\n7. Updated a test relying on operator `>` working for comparing language objects to a string, which will be deprecated by R, [#5977](https://github.com/Rdatatable/data.table/issues/5977); no user-facing effect. Thanks to R-core for continuously improving the language.\n\n8. Improved OpenMP detection when building from source on Mac, [#4348](https://github.com/Rdatatable/data.table/issues/4348). Thanks @jameshester and @kevinushey for the request and @kevinushey for the PR, @jameslamb for the advice and @s-u of R-core for ensuring CRAN machines are configured to support the expected setup.\n\n9. `test.data.table()` runs more robustly:\n\n a. In sessions where the `digits` or `warn` options are not their defaults (`7` and `0`, respectively), [#5285](https://github.com/Rdatatable/data.table/issues/5285). Thanks @OfekShilon for the report and suggested fix and @MichaelChirico for the PR.\n\n b. In locales where `letters != sort(letters)`, e.g. Latvian, [#3502](https://github.com/Rdatatable/data.table/issues/3502). Thanks @minemR for the report and @MichaelChirico for the fix.\n\n---\n\n* gains argument `strip.white` which is `TRUE` by default (unlike `base::read.table`). All unquoted columns' leading and trailing white spaces are automatically removed. If \\code{FALSE}, only trailing spaces of header is removed. Closes [#1113](https://github.com/Rdatatable/data.table/issues/1113), [#1035](https://github.com/Rdatatable/data.table/issues/1035), [#1000](https://github.com/Rdatatable/data.table/issues/1000), [#785](https://github.com/Rdatatable/data.table/issues/785), [#529](https://github.com/Rdatatable/data.table/issues/529) and [#956](https://github.com/Rdatatable/data.table/issues/956). Thanks to @dmenne, @dpastoor, @GHarmata, @gkalnytskyi, @renqian, @MatthewForrest, @fxi and @heraldb.\n * doesn't warn about empty lines when 'nrow' argument is specified and that many rows are read properly. Thanks to @richierocks for the report. Closes [#1330](https://github.com/Rdatatable/data.table/issues/1330).\n * doesn't error/warn about not being able to read last 5 lines when 'nrow' argument is specified. Thanks to @robbig2871. Closes [#773](https://github.com/Rdatatable/data.table/issues/773).\n\n---\n\nrequire(data.table)\ntest.data.table(script=\"types.Rraw\")\n\n---\n\n#: data.table.R:1225\n#, c-format\nmsgid \"\"\n\"A shallow copy of this data.table was taken so that := can add or remove %d \"\n\"columns by reference. At an earlier point, this data.table was copied by R \"\n\"(or was created manually using structure() or similar). Avoid names<- and \"\n\"attr<- which in R currently (and oddly) may copy the whole data.table. Use \"\n\"set* syntax instead to avoid copying: ?set, ?setnames and ?setattr. It's \"\n\"also not unusual for data.table-agnostic packages to produce tables affected \"\n\"by this issue. If this message doesn't help, please report your use case to \"\n\"the data.table issue tracker so the root cause can be fixed or this message \"\n\"improved.\"\nmsgstr \"\"\n\"Une copie (shallow) du data.table a été utilisée afin que := puisse ajouter \"\n\"ou supprimer %d colonnes par référence. Ce data.table a été copié \"\n\"antérieurement par R (ou a été créé manuellement en utilisant structure() ou \"\n\"similaire). Évitez names<- et attr<- qui, dans R, peuvent actuellement (et \"\n\"bizarrement) copier tout le data.table. Utilisez plutôt la syntaxe set* à la \"\n\"place pour éviter la copie : ?set, ?setnames et ?setattr. Il est aussi \"\n\"fréquent que les packages qui ne reconnaissent pas les data.tables génèrent \"\n\"des tables concernées par ce problème. Si ce message ne vous aide pas, \"\n\"veuillez rapporter votre cas d'utilisation dans le gestionnaire de tickets \"\n\"de data.table (issue tracker) afin que la cause première puisse être \"\n\"corrigée ou que ce message soit amélioré.\"\n\n#: data.table.R:1285\n#, c-format\nmsgid \"\"\n\"Variable '%s' is not found in calling scope. Looking in calling scope \"\n\"because this symbol was prefixed with .. in the j= parameter.\"\nmsgstr \"\"\n\"La variable '%s' n'est pas visible dans le contexte de l'appelant désigné \"\n\"par le préfixe .. du symbole dans le paramètre j= .\"\n\n#: data.table.R:1358\n#, c-format\nmsgid \"\"\n\"j (the 2nd argument inside [...]) is a single symbol but column name '%1$s' \"\n\"is not found. If you intended to select columns using a variable in calling \"\n\"scope, please try DT[, ..%1$s]. The .. prefix conveys one-level-up similar \"\n\"to a file system path.\"\nmsgstr \"\"\n\"j (le deuxième argument à l'intérieur de [...]) est un symbole unique mais \"\n\"le nom de la colonne '%1$s' n'est pas trouvé. Si vous souhaitez sélectionner \"\n\"des colonnes à l'aide d'une variable dans la portée de l'appelant, essayez \"\n\"DT[, ..%1$s]. Le préfixe .. indique un niveau supérieur similaire à celui \"\n\"d'un chemin d'accès pour un système de fichiers.\"\n\n#: data.table.R:1408\nmsgid \"\"\n\"Growing vector of column pointers from truelength %d to %d. A shallow copy \"\n\"has been taken, see ?setalloccol. Only a potential issue if two variables \"\n\"point to the same data (we can't yet detect that well) and if not you can \"\n\"safely ignore this. To avoid this message you could setalloccol() first, \"\n\"deep copy first using copy(), wrap with suppressWarnings() or increase the \"\n\"'datatable.alloccol' option.\"\nmsgstr \"\"\n\"Vecteur croissant des pointeurs de colonnes de truelength %d à %d. Une copie \"\n\"(shallow) a été faite, voir ?setalloccol. Il reste seulement un problème \"\n\"potentiel quand deux variables pointent sur les mêmes données (il n'est pas \"\n\"encore possible de détecter cela correctement) mais vous pouvez l'ignorer si \"\n\"ce n'est pas le cas. Pour éviter ce message utilisez d'abord setalloccol(), \"\n\"puis copiez le tout avec copy(), encadrez avec suppressWarnings() ou \"\n\"augmentez l'option 'datatable.alloccol'.\"\n\n#: data.table.R:1410\nmsgid \"\"\n\"Note that the shallow copy will assign to the environment from which := was \"\n\"called. That means for example that if := was called within a function, the \"\n\"original table may be unaffected.\"\nmsgstr \"\"\n\"Noter que la copie (shallow) sera fonction de l'environnement dans lequel := \"\n\"a été appelé. Ce qui signifie par exemple que si := est appelé d'une \"\n\"fonction, il est possible que la table originale ne soit pas modifiée.\"\n\n---\n\nUsing Regular Expressions and the nc Package Toby Dylan Hocking 2021.05 Update about data reshaping and visualization in R and python Toby Dylan Hocking 2021.05 Hamburg RUG: A professional trading research system in R Daniel Brandt 2021.05 The new R pipe Elio Campitelli 2021.04 10 Tips And Tricks For Data Scientists Vol.6 George Pipis 2021.04 Not data.table vs dplyr... data.table + dplyr! Matt Dancho 2021.03 Some data.table tips John MacKintosh 2021.03 Data.Table – everything you need to know to get you started in R Gary Hutson 2021.02 I wrote one of the fastest DataFrame libraries (hacker news) Ritchie Vink 2021.02 Joins vs case whens - speed and memory tradeoffs Thomas Mock 2021.02 The unequalled joy of non-equi joins David Selby 2021.02 Measuring and Monitoring Arrow's Performance: Some Updated R Benchmarks (response) Jonathan Keane & Neal Richardson 2021.02 Bigger Data With Ease Using Apache Arrow, (response) (rebuttal) Neal Richardson 2021.01 Fast and Easy Aggregation of Multi-Type and Survey Data in R Sebastian Krantz 2021.01 How to create a stock screener Martin Bel 2020.12 You only need library(data.table) / 你只需要 library(data.table) (in Chinese) Xianying Tan (@shrektan) 2020.11 Comparing Common Operations in dplyr and data.table Martin Chan 2020.11 non-equi merge in data.table and epidemiology Denis Mongin 2020.10 The ultimate R data.table cheat sheet Sharon Machlis 2020.10 What is R data.table and Why is R data.table? (In Korean, 한국어) HongDon Lee 2020.10 Solving small problems with data.table John MacKintosh 2020.10 Python and R – Part 1: Exploring Data with Datatable David Lucey 2020.10 Decomposition and Smoothing with data.table, reticulate, and spatstat Tony ElHabr 2020.09 The Fastest Way To Read And Write Files In R George Pipis 2020.09 The treedata.table Package April Wright, Cristian Román-Palacios, Josef Uyeda 2020.09 Gotta go fast with \"{tidytable}\" Bruno Rodrigues 2020.09 Task 2 - Retail Strategy and Analytics Shrishti Vaish 2020.08 Solving small data problems with data.table John MacKintosh 2020.08 Replicating .SD in Python Datatable Samuel Oranyeli 2020.08 Let's Learn data.table (日本語) Uryu Shinya 2020.08 87th TokyoR Meetup Roundup: {data.table}, Bioconductor, & more! Ryo Nakagawara 2020.07 5 handy options in R data.table’s fread Sharon Machlis 2020.07 Even more reshape benchmarks Grant McDermott 2020.07 RvsPython #2: Pivoting Data From Long to Wide Form Benjamin Smith 2020.06 A gentle introduction to data.table @atrebas 2020.06 Reshape benchmarks Grant McDermott 2020.06 Selecting and Grouping Data with Python Datatable Samuel Oranyeli 2020.05 dtplyr speed benchmarks Iyar Lin 2020.05 Creating a data.table from C++ David Zimmermann, Leonardo Silvestri, Dirk Eddelbuettel 2020.04 Data manipulation libraries: Translating between data.table, pandas, dplyr Toby Dylan Hocking 2020.04 patientcounter John MacKintosh 2020.04 Fastest data operations with least memory in tidy syntax Tian-Yuan Huang 2020.04 W is for Write and Read Data – Fast Sara Locatelli 2020.03 Use data.table the tidy way: An ultimate tutorial of tidyfst Tian-Yuan Huang 2020.03 R data.table symbols and operators you should know Sharon Machlis 2020.03 Variable name in functions, it's easy with datatable Lino Galiana 2020.02 stringsAsFactors Kurt Hornik 2020.01 Programming with data.table John MacKintosh 2020.01 Blazing Fast Data Wrangling With R data.table Thu Vu 2020.01 New Timings for a Grouped In-Place Aggregation Task John Mount 2020.01 Base R, the tidyverse, and data.table: a comparison of R dialects to wrangle your data Jason Mercer 2019.12 4 great free tools that can make your R work more efficient, reproducible and robust Jozef Hajnala 2019.12 Why I don’t use the Tidyverse Holger K. von Jouanne-Diedrich 2019.11 dtplyr 1.0.0 Hadley Wickham 2019.10 Using ggplot2 Inside data.table John Lashlee 2019.10 Fast and Readable 'If Else' in R Tysson Barrett 2019.10 Data Joins: Speed and Efficiency of dplyr and data.table Tysson Barrett 2019.10 Comparing\n\n---\n\n/* This header file provides the interface used by other packages,\n and should be included once per package. */\n\n#ifndef _R_data_table_API_h_\n#define _R_data_table_API_h_\n\n/* number of R header files (possibly listing too many) */\n#include \n\n#ifdef HAVE_VISIBILITY_ATTRIBUTE\n # define attribute_hidden __attribute__ ((visibility (\"hidden\")))\n#else\n # define attribute_hidden\n#endif\n\n#ifdef __cplusplus\nextern \"C\" {\n#endif\n\n/* provided the interface for the function exported in\n ../src/init.c via R_RegisterCCallable()\t\t*/\n\n// subsetDT #3751\ninline SEXP attribute_hidden DT_subsetDT(SEXP x, SEXP rows, SEXP cols) {\n static SEXP(*fun)(SEXP, SEXP, SEXP) =\n (SEXP(*)(SEXP,SEXP,SEXP)) R_GetCCallable(\"data.table\", \"DT_subsetDT\");\n return fun(x,rows,cols);\n}\n// forder #4015\n// setalloccol alloccolwrapper setDT #4439\n\n/* permit opt-in to redefine shorter identifiers */\n#if defined(DATATABLE_REMAP_API)\n #define subsetDT DT_subsetDT\n#endif\n\n#ifdef __cplusplus\n}\n\n/* add a namespace for C++ use */\nnamespace dt {\n inline SEXP subsetDT(SEXP x, SEXP rows, SEXP cols) { return DT_subsetDT(x, rows, cols); }\n}\n\n#endif /* __cplusplus */\n\n#endif /* _R_data_table_API_h_ */\n\n---\n\n9. `DT[1, on=NULL]` now works for returning the first row, [#6579](https://github.com/Rdatatable/data.table/issues/6579). Thanks to @Kodiologist for the report and @tdhock for the PR.\n\n10. `tables()` now returns the correct size for data.tables over 2GiB, [#6607](https://github.com/Rdatatable/data.table/issues/6607). Thanks to @vlulla for the report and the PR.\n\n11. `rbindlist(l, use.names=TRUE)` can now handle different encodings for the column names in different entries of `l`, [#5452](https://github.com/Rdatatable/data.table/issues/5452). Thanks to @MEO265 for the report, and Benjamin Schwendinger for the fix.\n\n12. Added a `data.frame` method for `format_list_item()` to fix error printing data.tables with columns containing 1-column data.frames, [#6592](https://github.com/Rdatatable/data.table/issues/6592). Thanks to @r2evans for the bug report and fix.\n\n13. Auto-printing gets some substantial improvements\n - Suppression in `knitr` documents is now done by implementing a method for `knit_print` instead of looking up the call stack, [#6589](https://github.com/Rdatatable/data.table/pull/6589). The old way was fragile and wound up broken by some implementation changes in {knitr}. Thanks to @jangorecki for the report [#6509](https://github.com/Rdatatable/data.table/issues/6509) and @aitap for the fix.\n - `print()` methods for S3 subclasses of data.table (e.g. an object of class `c(\"my.table\", \"data.table\", \"data.frame\")`) no longer print where plain data.tables wouldn't, e.g. `myDT[, y := 2]`, [#3029](https://github.com/Rdatatable/data.table/issues/3029). The improved detection of auto-printing scenarios has the added benefit of _allowing_ print in highly explicit statements like `print(DT[, y := 2])`, obviating our recommendation since v1.9.6 to append `[]` to signal \"please print me\".\n\n14. Joins of `integer64` and `double` columns succeed when the `double` column has lossless `integer64` representation, [#4167](https://github.com/Rdatatable/data.table/issues/4167) and [#6625](https://github.com/Rdatatable/data.table/issues/6625). Previously, this only worked when the double column had lossless _32-bit_ integer representation. Thanks @MichaelChirico for the reports and fix.\n\n15. `DT[order(...)]` better matches `base::order()` behavior by (1) recognizing the `method=` argument (and erroring since this is not supported) and (2) accepting a vector of `TRUE`/`FALSE` in `decreasing=` as an alternative to using `-a` to convey \"sort `a` decreasing\", [#4456](https://github.com/Rdatatable/data.table/issues/4456). Thanks @jangorecki for the FR and @MichaelChirico for the PR.\n\n16. Assignment with `:=` to an S4 slot of an under-allocated data.table now works, [#6704](https://github.com/Rdatatable/data.table/issues/6704). Thanks @MichaelChirico for the report and fix.\n\n17. `as.data.table()` method for `data.frame`s (especially those with extended classes) is more consistent with `as.data.frame()` with respect to rention of attributes, [#5699](https://github.com/Rdatatable/data.table/issues/5699). Thanks @jangorecki for the report and fix.\n\n18. Grouped queries on keyed tables no longer return an incorrectly keyed result if the _ad hoc_ `by=` list has some function call (in particular, a function which happens to return a strictly decreasing function of the keys), e.g. `by=.(a = rev(a))`, [#5583](https://github.com/Rdatatable/data.table/issues/5583). Thanks @AbrJA for the report and @MichaelChirico for the fix.\n\n19. An integer overflow in `fread()` with lines longer than `2^(31/2)` bytes is prevented, [#6729](https://github.com/Rdatatable/data.table/issues/6729). The typical impact was no worse than a wrong initial allocation size, corrected later. Thanks to @TaikiSan21 for the report and @aitap for the fix.\n\n20. Fixed a memory issue causing segfaults in `forder`, [#6797](https://github.com/Rdatatable/data.table/issues/6797). Thanks @dkutner for the report and @MichaelChirico for the fix.\n\n---\n\n### BUG FIXES\n\n1. `fwrite()` respects `dec=','` for timestamp columns (`POSIXct` or `nanotime`) with sub-second accuracy, [#6446](https://github.com/Rdatatable/data.table/issues/6446). Thanks @kav2k for pointing out the inconsistency and @MichaelChirico for the PR.\n\n2. The data.table-only attribute `$.internal.selfref` is no longer set for data.frames. [#5286](https://github.com/Rdatatable/data.table/issues/5286). Thanks @OfekShilon for the report and fix.\n\n3. Tagging/naming arguments of `c()` in `j=c()` should now more closely follow base R conventions for concatenation of named lists during grouping, [#2311](https://github.com/Rdatatable/data.table/issues/2311). Naming an `lapply(.SD, FUN)` call as an argument of `c()` in `j` will now always cause that tag to get prepended (with a single dot separator) to the resulting column names. Additionally, naming a `list()` call as an argument of `c()` in `j` will now always cause that tag to get prepended to any names specified within the list call. This bug only affected queries with (1) `by=` grouping (2) `getOption(\"datatable.optimize\") >= 1L` and (3) `lapply(.SD, FUN)` in `j`.\n\n While the names returned by `data.table` when `j=c()` will now mostly follow base R conventions for concatenating lists, note that names which are completely unspecified will still be named positionally, matching the typical behavior in `j` and `data.table()`. according to position in `j` (e.g. `V1`, `V2`).\n \n Thanks to @franknarf1 for reporting and @myoung3 for the PR.\n\n ```r\n # tag 'mean' prepended to lapply()-named columns\n names(mtcars[, c(mean=lapply(.SD,sum)), by=\"cyl\", .SDcols=c(\"am\", \"carb\")])\n # [1] \"cyl\" \"mean.am\" \"mean.carb\"\n\n # tag 'mean' is prepended to the first named sublist, 'sum' to the second\n names(mtcars[, c(mean=list(a=mean(hp), b=mean(wt)), sum=lapply(.SD, sum)), by=\"cyl\", .SDcols=c(\"am\", \"carb\")])\n # [1] \"cyl\" \"mean.a\" \"mean.b\" \"sum.am\" \"sum.carb\"\n\n # strict base naming would result in names c(\"\", \"b\", \"c\") here\n names(mtcars[, c(list(mean(hp), b=mean(wt)), c=list(mean(cyl)))])\n # [1] \"V1\" \"b\" \"c\"\n ```\n\n4. Queries like `DT[, min(x):max(x)]` now work as expected, i.e. the same as `DT[, seq(min(x), max(x))]` or `with(DT, min(x):max(x))`, [#2069](https://github.com/Rdatatable/data.table/issues/2069). Shorthand like `DT[, a:b]` meaning \"select from columns `a` through `b`\" still works. Thanks to @franknarf1 for reporting, @jangorecki for the fix, and @MichaelChirico for follow-ups ensuring back-compatibility.\n\n5. `fread()` performance improves when specifying `Date` among `colClasses`, [#6105](https://github.com/Rdatatable/data.table/issues/6105). One implication of the change is that the column will be an `IDate` (which also inherits from `Date`), which may affect code strongly relying on the column class to be `Date` exactly; computations with `IDate` and `Date` columns should otherwise be the same. If you strongly prefer the `Date` class, run `as.Date()` explicitly following `fread()`. Thanks @scipima for the report and @MichaelChirico for the fix.\n\n6. `dt[, col]` now returns a copy of `col` also when it is a list column, as in any other case, [#4877](https://github.com/Rdatatable/data.table/issues/4877). Thanks to @tlapak for reporting and the PR.\n\n7. `rbindlist` and `rbind` binding `bit64::integer64` columns with `character`/`complex`/`list` columns now works, [#5504](https://github.com/Rdatatable/data.table/issues/5504). Thanks to @MichaelChirico for the request and @ben-schwen for the PR.\n\n8. Fixed possible segfault in `setDT(df); attr(df, key) <- value; set(df, ...)`, i.e. adding columns to an object with `set()` that was converted to data.table with `setDT()` and later had attributes add with `attr<-`, [#6410](https://github.com/Rdatatable/data.table/issues/6410). Thanks to @hongyuanjia for the report and @ben-schwen for the PR. Note that `setattr()` should be preferred for adding attributes to a data.table.\n\n---\n\n# one and two+ row cases of data.table, as.data.table and cbind involving list columns, given\n# the change to tests 1613.571-3 in PR#3471 in v1.12.4\n# in v1.12.2 and before :\n# data.table( data.table(1:2), list(c(\"a\",\"b\"),\"a\") )\n# V1 V2 NA\n# \n# 1: 1 a a\n# 2: 2 b a\n# i.e. passing a data.table() to data.table() changed the meaning of list() which was inconsistent,\n# and an NA column name was introduced too (a bug in itself)\n# from v1.12.4 :\n# V1 V2\n# \n# 1: 1 a,b\n# 2: 2 a\n# i.e. now easier to add the list column as intended, and it's consistent with\n# basic (i.e. not cbind-like) usage of data.table()\n# # changed in v1.12.4 ?\nans = data.table(V1=1, V2=2) # --------------------\ntest(2058.01, data.table( data.table(1), 2), ans) # no\ntest(2058.02, as.data.table(list(data.table(1), 2)), ans) # no\ntest(2058.03, cbind(data.table(1), 2), ans) # no\nans = data.table(V1=1, V2=list(2)) # 'basic' usage; i.e. not cbind-like\ntest(2058.04, sapply(ans, class), c(V1=\"numeric\", V2=\"list\")) # no\ntest(2058.05, data.table( data.table(1), list(2) ), ans) # yes\ntest(2058.06, as.data.table(list(data.table(1), list(2))), ans) # yes\ntest(2058.07, cbind(data.table(1), list(2)), ans) # yes\nans = data.table(V1=1:2, V2=list(c(\"a\",\"b\"),\"a\"))\ntest(2058.08, sapply(ans, class), c(V1=\"integer\", V2=\"list\")) # no\ntest(2058.09, data.table( data.table(1:2), list(c(\"a\",\"b\"),\"a\") ), ans) # yes\ntest(2058.10, as.data.table(list(data.table(1:2), list(c(\"a\",\"b\"),\"a\"))), ans) # yes\ntest(2058.11, cbind(data.table(1:2), list(c(\"a\",\"b\"),\"a\")), ans) # yes\ntest(2058.12, cbind(first=data.table(A=1:3), second=data.table(A=4, B=5:7)),\n data.table(first.A=1:3, second.A=4, second.B=5:7)) # no\ntest(2058.13, cbind(data.table(A=1:3), second=data.table(A=4, B=5:7)),\n data.table(A=1:3, second.A=4, second.B=5:7)) # no\ntest(2058.14, cbind(data.table(A=1,B=2),3), data.table(A=1,B=2,V2=3)) # no\nL = list(1:3, 4:6)\ntest(2058.15, as.data.table(L), data.table(V1=1:3, V2=4:6)) # no\n# retain all-blank list names as batchtools relies on in reg$defs[1,job.pars], #3581\nnames(L) = c(\"\",\"\")\ntest(2058.16, as.data.table(L), setnames(data.table(1:3, 4:6),c(\"\",\"\"))) # no\n# retain existing duplicate and blank names of a plain-list, just as 1.12.2 did\nL = list(1:3, 4:6, 7:9, 10:12)\nnames(L) = c(\"\",\"foo\",\"\",\"foo\")\ntest(2058.17, as.data.table(L),\n setnames(data.table(1:3, 4:6, 7:9, 10:12),c(\"\",\"foo\",\"\",\"foo\"))) # no\nL = list(1:3, NULL, 4:6)\ntest(2058.18, length(L), 3L)\ntest(2058.19, as.data.table(L), data.table(V1=1:3, V2=4:6)) # V2 not V3 # no\nDT = data.table(a=1:3, b=c(4,5,6))\ntest(2058.20, DT[,b:=list(NULL)], data.table(a=1:3)) # no\n\n---\n\n---\ntitle: \"Programming on data.table\"\ndate: \"`{r} Sys.Date()`\"\noutput:\n litedown::html_format\nvignette: >\n %\\VignetteIndexEntry{Programming on data.table}\n %\\VignetteEngine{litedown::vignette}\n \\usepackage[utf8]{inputenc}\n---\n\n```{r, echo=FALSE, file='_translation_links.R'}\n```\n`{r} .write.translation.links(\"Translations of this document are available in: %s\")`\n\n```{r init, include = FALSE}\nrequire(data.table)\nlitedown::reactor(comment = \"# \")\n```\n\n## Introduction\n\n`data.table`, from its very first releases, enabled the usage of `subset` and `with` (or `within`) functions by defining the `[.data.table` method. `subset` and `with` are base R functions that are useful for reducing repetition in code, enhancing readability, and reducing number the total characters the user has to type. This functionality is possible in R because of a quite unique feature called *lazy evaluation*. This feature allows a function to catch its arguments, before they are evaluated, and to evaluate them in a different scope than the one in which they were called. Let's recap usage of the `subset` function.\n\n```{r df_print, echo=FALSE}\nregisterS3method(\"print\", \"data.frame\", function(x, ...) {\n base::print.data.frame(head(x, 2L), ...)\n cat(\"...\\n\")\n invisible(x)\n})\n.opts = options(\n datatable.print.topn=2L,\n datatable.print.nrows=20L\n)\n```\n\n```{r subset}\nsubset(iris, Species == \"setosa\")\n```\n\nHere, `subset` takes the second argument and evaluates it within the scope of the `data.frame` given as its first argument. This removes the need for variable repetition, making it less prone to errors, and makes the code more readable.\n\n## Problem description\n\nThe problem with this kind of interface is that we cannot easily parameterize the code that uses it. This is because the expressions passed to those functions are substituted before being evaluated.\n\n### Example\n\n```{r subset_error, error=TRUE, purl=FALSE}\nmy_subset = function(data, col, val) {\n subset(data, col == val)\n}\nmy_subset(iris, Species, \"setosa\")\n```\n\n### Approaches to the problem\n\nThere are multiple ways to work around this problem.\n\n#### Avoid *lazy evaluation*\n\nThe easiest workaround is to avoid *lazy evaluation* in the first place, and fall back to less intuitive, more error-prone approaches like `df[[\"variable\"]]`, etc. \n\n```{r subset_nolazy}\nmy_subset = function(data, col, val) {\n data[data[[col]] == val & !is.na(data[[col]]), ]\n}\nmy_subset(iris, col = \"Species\", val = \"setosa\")\n```\n\nHere, we compute a logical vector of length `nrow(iris)`, then this vector is supplied to the `i` argument of `[.data.frame` to perform ordinary \"logical vector\"-based subsetting. To align with `subset()`, which also drops NAs, we need to include an additional use of `data[[col]]` to catch that. It works well enough for this simple example, but it lacks flexibility, introduces variable repetition, and requires user to change the function interface to pass the column name as a character rather than unquoted symbol. The more complex the expression we need to parameterize, the less practical this approach becomes.\n\n#### Use of `parse` / `eval`\n\nThis method is usually preferred by newcomers to R as it is, perhaps, the most straightforward conceptually. This way requires producing the required expression using string concatenation, parsing it, and then evaluating it.\n\n```{r subset_parse}\nmy_subset = function(data, col, val) {\n data = deparse(substitute(data))\n col = deparse(substitute(col))\n val = paste0(\"'\", val, \"'\")\n text = paste0(\"subset(\", data, \", \", col, \" == \", val, \")\")\n eval(parse(text = text)[[1L]])\n}\nmy_subset(iris, Species, \"setosa\")\n```\n\nWe have to use `deparse(substitute(...))` to catch the actual names of objects passed to function, so we can construct the `subset` function call using those original names. Although this provides unlimited flexibility with relatively low complexity, **use of `eval(parse(...))` should be avoided**. The main reasons are:\n\n---\n\n## Can base be changed to do this then, rather than a new package?\n`data.frame` is used _everywhere_ and so it is very difficult to make _any_ changes to it.\ndata.table _inherits_ from `data.frame`. It _is_ a `data.frame`, too. A data.table _can_ be passed to any package that _only_ accepts `data.frame`. When that package uses `[.data.frame` syntax on the data.table, it works. It works because `[.data.table` looks to see where it was called from. If it was called from such a package, `[.data.table` diverts to `[.data.frame`.\n\n## I've heard that data.table syntax is analogous to SQL.\nYes:\n\n - `i` $\\Leftrightarrow$ where\n - `j` $\\Leftrightarrow$ select\n - `:=` $\\Leftrightarrow$ update\n - `by` $\\Leftrightarrow$ group by\n - `i` $\\Leftrightarrow$ order by (in compound syntax)\n - `i` $\\Leftrightarrow$ having (in compound syntax)\n - `nomatch = NA` $\\Leftrightarrow$ outer join\n - `nomatch = NULL` $\\Leftrightarrow$ inner join\n - `mult = \"first\"|\"last\"` $\\Leftrightarrow$ N/A because SQL is inherently unordered\n - `roll = TRUE` $\\Leftrightarrow$ N/A because SQL is inherently unordered\n\nThe general form is:\n\n```r\nDT[where, select|update, group by][order by][...] ... [...]\n```\n\nA key advantage of column vectors in R is that they are _ordered_, unlike SQL[^2]. We can use ordered functions in `data.table` queries such as `diff()` and we can use _any_ R function from any package, not just the functions that are defined in SQL. A disadvantage is that R objects must fit in memory, but with several R packages such as `ff`, `bigmemory`, `mmap` and `indexing`, this is changing.\n\n[^2]: It may be a surprise to learn that `select top 10 * from ...` does _not_ reliably return the same rows over time in SQL. You do need to include an `order by` clause, or use a clustered index to guarantee row order; _i.e._, SQL is inherently unordered.\n\n## What are the smaller syntax differences between `data.frame` and data.table {#SmallerDiffs}\n\n---\n\n```{r test_id, message=FALSE, results=\"show\", echo=TRUE, warning=FALSE}\nrequire(data.table) # print?\nDT = data.table(x=1:3, y=4:6) # no\nDT # yes\nDT[, z := 7:9] # no\nprint(DT[, z := 10:12]) # yes\nif (1 < 2) DT[, a := 1L] # no\nDT # yes\n```\nSome text.\n\n---\n\n20. `!` at the head of the expression will no longer trigger a not-join if the expression is logical, #4650. Thanks to Arunkumar Srinivasan for reporting.\n\n 21. `rbindlist` now chooses the highest type per column, not the first, #2456. Up-conversion follows R defaults, with the addition of factors being the highest type. Also fixes #4981 for the specific case of `NA`'s.\n\n 22. `cbind(x,y,z,...)` now creates a data.table if `x` isn't a `data.table` but `y` or `z` is, unless `x` is a `data.frame` in which case a `data.frame` is returned (use `data.table(DF,DT)` instead for that).\n\n 23. `cbind(x,y,z,...)` and `data.table(x,y,z,...)` now retain keys of any `data.table` inputs directly (no sort needed, for speed). The result's key is `c(key(x), key(y), key(z), ...)`, provided, that the data.table inputs that have keys are not recycled and there are no ambiguities (i.e. duplicates) in column names.\n\n 24. `rbind/rbindlist` will preserve ordered factors if it's possible to do so; i.e., if a compatible global order exists, #4856 & #5019. Otherwise the result will be a `factor` and a *warning*.\n\n 25. `rbind` now has a `fill` argument, #4790. When `fill=TRUE` it will behave in a manner similar to plyr's `rbind.fill`. This option is incompatible with `use.names=FALSE`. Thanks to Arunkumar Srinivasan for the base code.\n\n 26. `rbind` now relies exclusively on `rbindlist` to bind `data.tables` together. This makes rbind'ing factors faster, #2115.\n\n 27. `DT[, as.factor('x'), with=FALSE]` where `x` is a column in `DT` is now equivalent to `DT[, \"x\", with=FALSE]` instead of ending up with an error, #4867. Thanks to tresbot for reporting [here on SO](https://stackoverflow.com/questions/18525976/converting-multiple-data-table-columns-to-factors-in-r).\n\n 28. `format.data.table` now understands 'formula' and displays embedded formulas as expected, FR #2591.\n\n 29. `{}` around `:=` in `j` now obtain desired result, but with a warning #2496. Now,\n ```R\n DT[, { `:=`(...)}] # now works\n DT[, {`:=`(...)}, by=(...)] # now works\n ```\n Thanks to Alex for reporting [here on SO](https://stackoverflow.com/questions/14541959/expression-syntax-for-data-table-in-r).\n\n 30. `x[J(2), a]`, where `a` is the key column sees `a` in `j`, #2693 and FAQ 2.8. Also, `x[J(2)]` automatically names the columns from `i` using the key columns of `x`. In cases where the key columns of `x` and `i` are identical, i's columns can be referred to by using `i.name`; e.g., `x[J(2), i.a]`. Thanks to mnel and Gabor for the discussion on datatable-help.\n\n 31. `print.data.table` gains `row.names`, default=TRUE. When FALSE, the row names (along with the :) are not printed, #5020. Thanks to Frank Erickson.\n\n 32. `.SDcols` now is also able to de-select columns. This works both with column names and column numbers.\n ```R\n DT[, lapply(.SD,...), by=..., .SDcols=-c(1,3)] # .SD all but columns 1 and 3\n DT[, lapply(.SD,...), by=..., .SDcols=-c(\"x\", \"z\")] # .SD all but columns 'x' and 'z'\n DT[..., .SDcols=c(1, -3)] # can't mix signs, error\n DT[, .SD, .SDcols=c(\"x\", -\"z\")] # can't mix signs, error\n ```\n Thanks to Tonny Peterson for filing FR #4979.\n\n 33. `as.data.table.list` now issues a warning for those items/columns that result in a remainder due to recycling, #4813. `data.table()` also now issues a warning (instead of an error previously) when recycling leaves a remainder; e.g., `data.table(x=1:2, y=1:3)`.\n\n 34. `:=` now coerces without warning when precision is not lost and `length(RHS) == 1`, #2551.\n ```R\n DT = data.table(x=1:2, y=c(TRUE, FALSE))\n DT[1, x:=1] # ok, now silent\n DT[1, y:=0] # ok, now silent\n DT[1, y:=0L] # ok, now silent\n ```\n\n 35. `as.data.table.*(x, keep.rownames=TRUE)`, where `x` is a named vector now adds names of `x` into a new column with default name `rn`. Thanks to Garrett See for FR #2356.\n\n---\n\n8. Compiler support for OpenMP is now detected during installation, which allows `data.table` to compile from source (in single threaded mode) on macOS which, frustratingly, does not include OpenMP support by default, [#2161](https://github.com/Rdatatable/data.table/issues/2161), unlike Windows and Linux. A helpful message is emitted during installation from source, and on package startup as before. Many thanks to @jimhester for the PR.\n\n9. `rbindlist` now supports columns of type `expression`, [#546](https://github.com/Rdatatable/data.table/issues/546). Thanks @jangorecki for the report.\n\n10. The dimensions of objects in a `list` column are now displayed, [#3671](https://github.com/Rdatatable/data.table/issues/3671). Thanks to @randomgambit for the request, and Tyson Barrett for the PR.\n\n11. `frank` gains `ties.method='last'`, paralleling the same in `base::order` which has been available since R 3.3.0 (April 2016), [#1689](https://github.com/Rdatatable/data.table/issues/1689). Thanks @abudis for the encouragement to accommodate this.\n\n12. The `keep.rownames` argument in `as.data.table.xts` now accepts a string, which can be used for specifying the column name of the index of the xts input, [#4232](https://github.com/Rdatatable/data.table/issues/4232). Thanks to @shrektan for the request and the PR.\n\n13. New symbol `.NGRP` available in `j`, [#1206](https://github.com/Rdatatable/data.table/issues/1206). `.GRP` (the group number) was already available taking values from `1` to `.NGRP`. The number of groups, `.NGRP`, might be useful in `j` to calculate a percentage of groups processed so far, or to do something different for the last or penultimate group, for example.\n\n14. Added support for `round()` and `trunc()` to extend functionality of `ITime`. `round()` and `trunc()` can be used with argument units: \"hours\" or \"minutes\". Thanks to @JensPederM for the suggestion and PR.\n\n15. A new throttle feature has been introduced to speed up small data tasks that are repeated in a loop, [#3175](https://github.com/Rdatatable/data.table/issues/3175) [#3438](https://github.com/Rdatatable/data.table/issues/3438) [#3205](https://github.com/Rdatatable/data.table/issues/3205) [#3735](https://github.com/Rdatatable/data.table/issues/3735) [#3739](https://github.com/Rdatatable/data.table/issues/3739) [#4284](https://github.com/Rdatatable/data.table/issues/4284) [#4527](https://github.com/Rdatatable/data.table/issues/4527) [#4294](https://github.com/Rdatatable/data.table/issues/4294) [#1120](https://github.com/Rdatatable/data.table/issues/1120). The default throttle of 1024 means that a single thread will be used when nrow<=1024, two threads when nrow<=2048, etc. To change the default, use `setDTthreads(throttle=)`. Or use the new environment variable `R_DATATABLE_THROTTLE`. If you use `Sys.setenv()` in a running R session to change this environment variable, be sure to run an empty `setDTthreads()` call afterwards for the change to take effect; see `?setDTthreads`. The word *throttle* is used to convey that the number of threads is restricted (throttled) for small data tasks. Reducing throttle to 1 will turn off throttling and should revert behaviour to past versions (i.e. using many threads even for small data). Increasing throttle to, say, 65536 will utilize multi-threading only for larger datasets. The value 1024 is a guess. We welcome feedback and test results indicating what the best default should be.\n\n### BUG FIXES\n\n1. A NULL timezone on POSIXct was interpreted by `as.IDate` and `as.ITime` as UTC rather than the session's default timezone (`tz=\"\"`) , [#4085](https://github.com/Rdatatable/data.table/issues/4085).\n\n2. `DT[i]` could segfault when `i` is a zero-column `data.table`, [#4060](https://github.com/Rdatatable/data.table/issues/4060). Thanks @shrektan for reporting and fixing.\n\n---\n\n---\ntitle: \"Reference semantics\"\ndate: \"`{r} Sys.Date()`\"\noutput:\n litedown::html_format\nvignette: >\n %\\VignetteIndexEntry{Reference semantics}\n %\\VignetteEngine{litedown::vignette}\n \\usepackage[utf8]{inputenc}\n---\n\n```{r, echo=FALSE, file='_translation_links.R'}\n```\n`{r} .write.translation.links(\"Translations of this document are available in: %s\")`\n\n```{r, echo = FALSE, message = FALSE}\nlibrary(data.table)\nlitedown::reactor(comment = \"# \")\n.old.th = setDTthreads(1)\n```\n\nThis vignette discusses *data.table*'s reference semantics which allows to *add/update/delete* columns of a *data.table by reference*, and also combine them with `i` and `by`. It is aimed at those who are already familiar with *data.table* syntax, its general form, how to subset rows in `i`, select and compute on columns, and perform aggregations by group. If you're not familiar with these concepts, please read the [`vignette(\"datatable-intro\", package=\"data.table\")`](datatable-intro.html) vignette first.\n\n***\n\n## Data {#data}\n\nWe will use the same `flights` data as in the [`vignette(\"datatable-intro\", package=\"data.table\")`](datatable-intro.html) vignette.\n\n```{r, echo = FALSE}\noptions(width = 100L)\n```\n\n```{r}\nflights <- fread(\"flights14.csv\")\nflights\ndim(flights)\n```\n\n## Introduction\n\nIn this vignette, we will\n\n1. first discuss reference semantics briefly and look at the two different forms in which the `:=` operator can be used\n\n2. then see how we can *add/update/delete* columns *by reference* in `j` using the `:=` operator and how to combine with `i` and `by`.\n\n3. and finally we will look at using `:=` for its *side-effect* and how we can avoid the side effects using `copy()`.\n\n## 1. Reference semantics\n\nAll the operations we have seen so far in the previous vignette resulted in a new data set. We will see how to *add* new column(s), *update* or *delete* existing column(s) on the original data.\n\n### a) Background\n\nBefore we look at *reference semantics*, consider the *data.frame* shown below:\n\n```{r}\nDF = data.frame(ID = c(\"b\",\"b\",\"b\",\"a\",\"a\",\"c\"), a = 1:6, b = 7:12, c = 13:18)\nDF\n```\n\nWhen we did:\n\n```r\nDF$c <- 18:13 # (1) -- replace entire column\n# or\nDF$c[DF$ID == \"b\"] <- 15:13 # (2) -- subassign in column 'c'\n```\n\nboth (1) and (2) resulted in deep copy of the entire data.frame in versions of `R < 3.1`. [It copied more than once](https://stackoverflow.com/q/23898969/559784). To improve performance by avoiding these redundant copies, *data.table* utilised the [available but unused `:=` operator in R](https://stackoverflow.com/q/7033106/559784).\n\nGreat performance improvements were made in `R v3.1` as a result of which only a *shallow* copy is made for (1) and not *deep* copy. However, for (2) still, the entire column is *deep* copied even in `R v3.1+`. This means the more columns one subassigns to in the *same query*, the more *deep* copies R does.\n\n#### *shallow* vs *deep* copy\n\nA *shallow* copy is just a copy of the vector of column pointers (corresponding to the columns in a *data.frame* or *data.table*). The actual data is not physically copied in memory.\n\nA *deep* copy on the other hand copies the entire data to another location in memory.\n\nWhen subsetting a *data.table* using `i` (e.g., `DT[1:10]`), a *deep* copy is made. However, when `i` is not provided or equals `TRUE`, a *shallow* copy is made.\n\n#\nWith *data.table's* `:=` operator, absolutely no copies are made in *both* (1) and (2), irrespective of R version you are using. This is because `:=` operator updates *data.table* columns *in-place* (by reference).\n\n### b) The `:=` operator\n\nIt can be used in `j` in two ways:\n\n(a) The `LHS := RHS` form\n\n```r\nDT[, c(\"colA\", \"colB\", ...) := list(valA, valB, ...)]\n\n# when you have only one column to assign to you\n# can drop the quotes and list(), for convenience\nDT[, colA := valA]\n```\n\n(b) The functional form\n\n```r\nDT[, `:=`(colA = valA, # valA is assigned to colA\n colB = valB, # valB is assigned to colB\n ...\n)]\n```\n\n---\n\n# Test case created directly using the atime code below (not adapted from any other benchmark), based on the PR, Removes unnecessary data.table call from as.data.table.array https://github.com/Rdatatable/data.table/pull/7010 \n \"as.data.table.array improved in #7010\" = atime::atime_test(\n setup = {\n dims = c(N, 1, 1)\n arr = array(seq_len(prod(dims)), dim=dims)\n },\n expr = data.table:::as.data.table.array(arr, na.rm=FALSE),\n Slow = \"73d79edf8ff8c55163e90631072192301056e336\", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/8397dc3c993b61a07a81c786ca68c22bc589befc)\n Fast = \"8397dc3c993b61a07a81c786ca68c22bc589befc\"), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7019/commits) that removes inefficiency\n\n \"isoweek improved in #7144\" = atime::atime_test(\n setup = {\n set.seed(349)\n x = sample(Sys.Date() - 0:5000, N, replace=TRUE)\n },\n expr = data.table::isoweek(x),\n Slow = \"548410d23dd74b625e8ea9aeb1a5d2e9dddd2927\", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/548410d23dd74b625e8ea9aeb1a5d2e9dddd2927)\n Fast = \"c0b32a60466bed0e63420ec105bc75c34590865e\"), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7144/commits) that uses a much faster implementation\n\n # Regression introduced in #7404 (grouped by factor).\n \"DT[by] max regression fixed in #7480\" = atime::atime_test(\n N = as.integer(10^seq(3, 5, by=0.5)),\n setup = {\n dt = data.table(\n id = as.factor(rep(seq_len(N), each = 100L)),\n V1 = 1L\n )\n },\n expr = data.table:::`[.data.table`(dt, , base::max(V1, na.rm = TRUE), by = id),\n Before = \"476de7e3\",\n Regression = \"6f49bf1\",\n Fixed = \"b6ad1a4\",\n seconds.limit = 1),\n tests=extra.test.list)\n# nolint end: undesirable_operator_linter.\n\n---\n\nrequire(methods)\nif (exists(\"test.data.table\", .GlobalEnv, inherits=FALSE)) {\n if ((tt<-compiler::enableJIT(-1))>0)\n cat(\"This is dev mode and JIT is enabled (level \", tt, \") so there will be a brief pause around the first test.\\n\", sep=\"\")\n} else {\n require(data.table)\n test = data.table:::test\n null.data.table = data.table:::null.data.table\n INT = data.table:::INT\n}\n\nsugg = c(\"bit64\")\nfor (s in sugg) {\n assign(paste0(\"test_\",s), loaded<-suppressWarnings(suppressMessages(\n library(s, character.only=TRUE, logical.return=TRUE, quietly=TRUE, warn.conflicts=FALSE, pos=\"package:base\") # attach at the end for #5101\n )))\n if (!loaded) cat(\"\\n**** Suggested package\",s,\"is not installed or has dependencies missing. Tests using it will be skipped.\\n\\n\")\n}\n\n# := by group\nDT = data.table(a=1:3,b=(1:9)/10)\ntest(611.1,optimize=c(0L, 2L), DT[,v:=sum(b),by=a], data.table(a=1:3,b=(1:9)/10,v=c(1.2,1.5,1.8)))\nsetkey(DT,a)\ntest(611.2,optimize=c(0L, 2L), DT[,v:=min(b),by=a], data.table(a=1:3,b=(1:9)/10,v=(1:3)/10,key=\"a\"))\n# Combining := by group with i\ntest(611.3,optimize=c(0L, 2L), DT[a>1,p:=sum(b)]$p, rep(c(NA,3.3),c(3,6)))\ntest(611.4,optimize=c(0L, 2L), DT[a>1,q:=sum(b),by=a]$q, rep(c(NA,1.5,1.8),each=3))\n# 612 was just level repetition of 611\n# Assign to subset ok (NA initialized in the other items) ok :\ntest(613,optimize=c(0L, 2L), DT[J(2),w:=8.3]$w, rep(c(NA,8.3,NA),each=3))\ntest(614,optimize=c(0L, 2L), DT[J(3),x:=9L]$x, rep(c(NA_integer_,NA_integer_,9L),each=3))\ntest(615,optimize=c(0L, 2L), DT[J(2),z:=list(list(c(10L,11L)))]$z, rep(list(NULL, 10:11, NULL),each=3))\n# 616, 617 removed in #5245\n\n# Empty i clause, #2034. Thanks to Chris for testing, tests from him. Plus changes from #759\nans = copy(DT)[,r:=NA_real_]\ntest(618.1,optimize=c(0L, 2L), copy(DT)[a>3,r:=sum(b)], ans)\ntest(618.2,optimize=c(0L, 2L), copy(DT)[J(-1),r:=sum(b)], ans)\ntest(618.3,optimize=c(0L, 2L), copy(DT)[NA,r:=sum(b)], ans)\ntest(618.4,optimize=c(0L, 2L), copy(DT)[0,r:=sum(b)], ans)\ntest(618.5,optimize=c(0L, 2L), copy(DT)[NULL,r:=sum(b)], null.data.table())\n# test 619 was level 2 of 618\n# test 620 was removed in #5245\n\nDT = data.table(x=letters, key=\"x\")\ntest(621,optimize=c(0L, 2L), copy(DT)[J(\"bb\"), x:=\"foo\"], DT) # when no update, key should be retained\ntest(622,optimize=c(0L, 2L), copy(DT)[J(\"bb\"), x:=\"foo\",nomatch=0], DT, warning=\"ignoring nomatch\")\n\nset.seed(2)\nDT = data.table(a=rnorm(5)*10, b=1:5)\ntest(623,optimize=c(0L, 2L), copy(DT)[,s:=sum(b),by=round(a)%%2]$s, c(10L,5L,5L,10L,10L))\n# test 623 subsumes 623.1 and 623.2 for testing both levels\n\n# Setup for test 656.x - gforce tests\nset.seed(9)\nn = 1e3\nDT = data.table(grp1=sample.int(150L, n, replace=TRUE),\n grp2=sample.int(150L, n, replace=TRUE),\n x=rnorm(n),\n y=rnorm(n))\nopt = 0:2\nout = c('GForce FALSE', 'GForce FALSE' ,'GForce TRUE')\ntest(656.1,optimize=opt, DT[ , mean(x), by=grp1, verbose=TRUE], output=out)\ntest(656.2,optimize=opt, DT[ , list(mean(x)), by=grp1, verbose=TRUE], output=out)\ntest(656.3,optimize=opt, DT[ , list(mean(x), mean(y)), by=grp1, verbose=TRUE], output=out)\n# 657-658 were for levels 1,2, resp.\n\n---\n\n### Testing\n\n`data.table` uses a series of unit tests to exhibit code that is expected to work. These are primarily stored in [`inst/tests/tests.Rraw`](https://github.com/Rdatatable/data.table/blob/master/inst/tests/tests.Rraw). They come primarily from two places -- when new features are implemented, the author constructs minimal examples demonstrating the expected common usage of said feature, including expected failures/invalid use cases (e.g., the [initial assay of `fwrite` included 24 tests](https://github.com/Rdatatable/data.table/pull/1613/files#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae)). Second, when kind users such as yourself happen upon some aberrant behavior in their everyday use of `data.table` (typically, some edge case that slipped through the cracks in the coding logic of the original author). We try to be thorough -- for example there were initially [141 tests of `split.data.table`](https://github.com/Rdatatable/data.table/commit/5f7a435fea5622bfbe1d5f1ffa99fa94a6a054ae#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae), and that number has since grown!\n\nWhen you file a pull request, you should add some tests to this file with this in mind -- for new features, try to cover possible use cases extensively (we use [Codecov](https://app.codecov.io/gh/Rdatatable/data.table) to make it a bit easier to see how well you've done to minimally cover any new code you've added); for bug fixes, include a minimal version of the problem you've identified and write a test to ensure that your fix indeed works, and thereby guarantee that your fix continues to work as the codebase is further modified in the future. We encourage you to scroll around in `tests.Rraw` a bit to get a feel for the types of examples that are being created, and how bugs are tested/features evaluated.\n\nWhat numbers should be used for new tests? Numbers should be new relative to current master at the time of your PR. If another PR is merged before yours, then there may be a conflict, but that is no problem, as [a Committer will fix the test numbers when merging your PR](https://github.com/Rdatatable/data.table/pull/4731#issuecomment-768858134).\n\n#### Using `test`\n\nSee [`?test`](https://rdatatable.gitlab.io/data.table/reference/test.html).\n\n**References:** If you are not sure how to create a PR, but would like to contribute, these links should help get you started:\n\n1. **[How to Github: Fork, Branch, Track, Squash and Pull request](https://gun.io/blog/how-to-github-fork-branch-and-pull-request/)**.\n1. **[Squashing Github pull requests into a single commit](http://eli.thegreenplace.net/2014/02/19/squashing-github-pull-requests-into-a-single-commit)**.\n1. **[Github help](https://help.github.com/articles/using-pull-requests/)** - you'll need the *fork and pull* model.\n\n#### Performance testing\n\nIf your PR may have an effect on time/memory usage, please consider adding a performance test, either in the same PR, or a follow-up PR. Note that first-time contributors _must_ do so in a follow-up PR, since the tests are only run on PRs from branches created directly in the Rdatatable/data.table repo. See the [Performance testing](https://github.com/Rdatatable/data.table/wiki/Performance-testing) wiki page for details.\n\nMinimal first time PR\n---------------------\n\n```shell\ncd /tmp # or anywhere safe to play\ngit config --global core.autocrlf false # Windows-only preserve \\n in test data\ngit clone https://github.com/Rdatatable/data.table.git\ncd data.table\nR CMD build .\nR CMD check data.table_*.tar.gz\n# ...\n# Status: OK\n```\n\nCongratulations - you've just compiled and tested the very latest version of data.table in development. Everything looks good. Now make your changes. Using an editor of your choice, edit the appropriate `.R`, `.md`, `NEWS` and `tests.Rraw` files. Test your changes:\n\n```shell\nrm data.table_*.tar.gz # clean-up old build(s)\nR CMD build .\nR CMD check data.table_*.tar.gz\n```\n\n---\n\n# Moved here out from data.table.R on 10 Aug 2017. See data.table.R for history prior to that.\n\n---\n\n# if a change in the number of columns is suspected\n if (ok==0L) # ok==0 so no warning when loaded from disk (-1) [-1 considered TRUE by R]\n if (is.data.table(x)) warningf(\"A shallow copy of this data.table was taken so that := can add or remove %d columns by reference. At an earlier point, this data.table was copied by R (or was created manually using structure() or similar). Avoid names<- and attr<- which in R currently (and oddly) may copy the whole data.table. Use set* syntax instead to avoid copying: ?set, ?setnames and ?setattr. It's also not unusual for data.table-agnostic packages to produce tables affected by this issue. If this message doesn't help, please report your use case to the data.table issue tracker so the root cause can be fixed or this message improved.\", length(newnames))\n }\n # ok <- selfrefok above called without verbose -- only activated when\n # ok=-1 which will trigger setalloccol with verbose in the next\n # branch, which again calls _selfrefok and returns the message then\n # !is.data.table for DF |> DT(,:=) tests 2212.16-19 (#5113) where a shallow copy is routine for data.frame\n if (\n (\n !is.null(newnames) || # adding new columns\n is.null(jsub) || (jsub %iscall% \"list\" && any(vapply_1b(jsub[-1], is.null))) # removing columns\n ) && (\n (ok<1L) || # unsafe to resize\n (truelength(x) < ncol(x)+length(newnames)) # not enough space for new columns\n )\n ) {\n DT = x # in case getOption contains \"ncol(DT)\" as it used to. TODO: warn and then remove\n n = length(newnames) + eval(getOption(\"datatable.alloccol\")) # TODO: warn about expressions and then drop the eval()\n # i.e. reallocate at the size as if the new columns were added followed by setalloccol().\n name = substitute(x)\n if (is.name(name) && ok && verbose) { # && NAMED(x)>0 (TO DO) # ok here includes -1 (loaded from disk)\n catf(\"Growing vector of column pointers from truelength %d to %d. A shallow copy has been taken, see ?setalloccol. Only a potential issue if two variables point to the same data (we can't yet detect that well) and if not you can safely ignore this. To avoid this message you could setalloccol() first, deep copy first using copy(), wrap with suppressWarnings() or increase the 'datatable.alloccol' option.\\n\", truelength(x), n)\n # #1729 -- copying to the wrong environment here can cause some confusion\n if (ok == -1L) catf(\"Note that the shallow copy will assign to the environment from which := was called. That means for example that if := was called within a function, the original table may be unaffected.\\n\")\n\n---\n\n7. Efficient conversion of `xts` to data.table. Closes [#882](https://github.com/Rdatatable/data.table/issues/882). Check examples in `?as.xts.data.table` and `?as.data.table.xts`. Thanks to @jangorecki for the PR.\n\n 8. `rbindlist` gains `idcol` argument which can be used to generate an index column. If `idcol=TRUE`, the column is automatically named `.id`. Instead you can also provide a column name directly. If the input list has no names, indices are automatically generated. Closes [#591](https://github.com/Rdatatable/data.table/issues/591). Also thanks to @KevinUshey for filing [#356](https://github.com/Rdatatable/data.table/issues/356).\n\n 9. A new helper function `uniqueN` is now implemented. It is equivalent to `length(unique(x))` but much faster. It handles `atomic vectors`, `lists`, `data.frames` and `data.tables` as input and returns the number of unique rows. Closes [#884](https://github.com/Rdatatable/data.table/issues/884). Gains by argument. Closes [#1080](https://github.com/Rdatatable/data.table/issues/1080). Closes [#1224](https://github.com/Rdatatable/data.table/issues/1224). Thanks to @DavidArenburg, @kevinmistry and @jangorecki.\n\n 10. Implemented `transpose()` to transpose a list and `tstrsplit` which is a wrapper for `transpose(strsplit(...))`. This is particularly useful in scenarios where a column has to be split and the resulting list has to be assigned to multiple columns. See `?transpose` and `?tstrsplit`, [#1025](https://github.com/Rdatatable/data.table/issues/1025) and [#1026](https://github.com/Rdatatable/data.table/issues/1026) for usage scenarios. Closes both #1025 and #1026 issues.\n * Implemented `type.convert` as suggested by Richard Scriven. Closes [#1094](https://github.com/Rdatatable/data.table/issues/1094).\n\n 11. `melt.data.table`\n * can now melt into multiple columns by providing a list of columns to `measure.vars` argument. Closes [#828](https://github.com/Rdatatable/data.table/issues/828). Thanks to Ananda Mahto for the extended email discussions and ideas on generating the `variable` column.\n * also retains attributes wherever possible. Closes [#702](https://github.com/Rdatatable/data.table/issues/702) and [#993](https://github.com/Rdatatable/data.table/issues/993). Thanks to @richierocks for the report.\n * Added `patterns.Rd`. Closes [#1294](https://github.com/Rdatatable/data.table/issues/1294). Thanks to @MichaelChirico.\n\n 12. `.SDcols`\n * understands `!` now, i.e., `DT[, .SD, .SDcols=!\"a\"]` now works, and is equivalent to `DT[, .SD, .SDcols = -c(\"a\")]`. Closes [#1066](https://github.com/Rdatatable/data.table/issues/1066).\n * accepts logical vectors as well. If length is smaller than number of columns, the vector is recycled. Closes [#1060](https://github.com/Rdatatable/data.table/issues/1060). Thanks to @StefanFritsch.\n\n 13. `dcast` can now:\n * cast multiple `value.var` columns simultaneously. Closes [#739](https://github.com/Rdatatable/data.table/issues/739).\n * accept multiple functions under `fun.aggregate`. Closes [#716](https://github.com/Rdatatable/data.table/issues/716).\n * supports optional column prefixes as mentioned under [this SO post](https://stackoverflow.com/q/26225206/559784). Closes [#862](https://github.com/Rdatatable/data.table/issues/862). Thanks to @JohnAndrews.\n * works with undefined variables directly in formula. Closes [#1037](https://github.com/Rdatatable/data.table/issues/1037). Thanks to @DavidArenburg for the MRE.\n * Naming conventions on multiple columns changed according to [#1153](https://github.com/Rdatatable/data.table/issues/1153). Thanks to @MichaelChirico for the FR.\n * also has a `sep` argument with default `_` for backwards compatibility. [#1210](https://github.com/Rdatatable/data.table/issues/1210). Thanks to @dbetebenner for the FR.\n\n---\n\n# .SD reference in '...' passed to lapply(FUN=) is recognized as data.table\ntest(2331, lapply(list(data.table(a=1:2)), `[`, j=.SD[1L]), list(data.table(a=1L)))\n\n# 5885 implement frev\nd = c(NA, NaN, Inf, -Inf)\ntest(2332.00, frev(c(FALSE, NA)), rev(c(FALSE, NA)))\ntest(2332.01, frev(c(0L, NA)), rev(c(0L, NA)))\ntest(2332.02, frev(d), rev(d))\ntest(2332.03, frev(c(NA, 1, 0+2i)), rev(c(NA, 1, 0+2i)))\ntest(2332.04, frev(as.raw(0:1)), rev(as.raw(0:1)))\ntest(2332.05, frev(NULL), rev(NULL))\ntest(2332.06, frev(character(5)), rev(character(5)))\ntest(2332.07, frev(integer(0)), rev(integer(0)))\ntest(2332.08, frev(list(1, \"a\")), rev(list(1, \"a\")))\ntest(2332.09, {x=c(0L, NA); setfrev(x); x}, c(NA, 0L))\ntest(2332.10, {x=d; setfrev(x); x}, c(-Inf, Inf, NaN, NA))\ntest(2332.11, {x=c(NA, 1, 0+2i); setfrev(x); x}, c(0+2i, 1, NA))\ntest(2332.12, {x=as.raw(0:1); setfrev(x); x}, as.raw(1:0))\ntest(2332.13, {x=NULL; setfrev(x); x}, NULL)\ntest(2332.14, {x=character(5); setfrev(x); x}, character(5))\ntest(2332.15, {x=integer(0); setfrev(x); x}, integer(0))\ntest(2332.16, {x=list(1, \"a\"); setfrev(x); x}, list(\"a\", 1))\ntest(2332.17, frev(1:1e2), rev(1:1e2))\n# copy arguments\nx = 1:3\ntest(2332.21, {frev(x); x}, 1:3)\ntest(2332.22, {setfrev(x); x}, 3:1)\ntest(2332.23, address(x) == address(setfrev(x)))\ntest(2332.24, address(x) != address(frev(x)))\n# do not alter on subsets\ntest(2332.25, {setfrev(x[1:2]); x}, 1:3)\n# levels\nf = as.factor(letters)\ntest(2332.31, frev(f), rev(f))\ntest(2332.32, frev(as.IDate(1:10)), as.IDate(10:1))\ntest(2332.33, frev(as.IDate(1:10)), as.IDate(10:1))\n# names\nx = c(a=1L, b=2L, c=3L)\ntest(2332.41, frev(x), rev(x))\ntest(2332.42, setfrev(x), x)\nx = c(a=1L, b=2L, c=3L)\ntest(2332.43, {frev(x); names(x)}, c(\"a\",\"b\",\"c\"))\n# attributes\nx = structure(1:10, class = c(\"IDate\", \"Date\"), att = 1L)\ntest(2332.51, attr(frev(x), \"att\"), attr(rev(x), \"att\"))\ntest(2332.52, class(frev(x)), class(rev(x)))\ntest(2332.53, attr(setfrev(x), \"att\"), 1L)\ntest(2332.54, class(setfrev(x)), c(\"IDate\", \"Date\"))\nx = structure(integer(0), att = 1L)\ntest(2332.55, attr(frev(x), \"att\"), attr(rev(x), \"att\"))\n# errors\ntest(2332.61, frev(data.table()), error=\"should not be data.frame or data.table\")\ntest(2332.62, frev(expression(1)), error=\"is not supported by frev\")\nif (test_bit64) {\n x = as.integer64(c(1, NA, 3))\n test(2332.71, frev(x), rev(x))\n test(2332.72, setfrev(x), x)\n}\n# support rotate idiom\nM1 = M2 = matrix(1:4, nrow=2)\ntest(2332.81, {M1[]=frev(M1); M1}, {M2[]=rev(M2); M2})\n\n# regression test of edge case report #4964\ntest(2333, as.expression(data.table(a = 1))[[\"a\"]], 1)\n\n# regression test for hexdigits subscript overrun (uint8_t wraps over 255, unsigned overflow is well defined in c)\nlocal({\n f = tempfile()\n on.exit(unlink(f))\n # the line is likely invalid in current encoding, so disable any translation, #7209\n # test.data.table() sets options(encoding=\"UTF-8\"), so go the long way around.\n ff = file(f, encoding = \"\")\n tryCatch(\n writeLines(c('a', rep('0x1.ffffp0', 10000L), `Encoding<-`('0x1.ff\\x9fp0', 'bytes'), rep('0x1.ffffp0', 20000L)), ff),\n finally = close(ff)\n )\n test(2334, names(fread(f)), \"a\")\n})\n\n# Tests for new isoyear() helper (complement to isoweek) #7154\ntest(2335.1, isoyear(as.IDate(\"2019-12-30\")), 2020L) # End of year edge case\ntest(2335.2, isoyear(as.IDate(\"2016-01-01\")), 2015L) # Start of year edge case\ntest(2335.3, isoyear(as.IDate(\"2023-08-15\")), 2023L) # Normal mid-year case\ntest(2335.4, isoyear(as.IDate(c(\"2019-12-30\", \"2016-01-01\", \"2023-08-15\"))),c(2020L, 2015L, 2023L))\ntest(2335.5, isoyear(\"2019-12-30\"), 2020L)\ntest(2335.6, isoyear(as.Date(\"2019-12-30\")), 2020L)\n\n---\n\n#: data.table.R:816\n#, c-format\nmsgid \"by=c(...), key(...) or names(...) must evaluate to 'character'\"\nmsgstr \"\"\n\"результатом вычисления by=c(...), key(...) или names(...) должен быть вектор \"\n\"строк\"\n\n#: data.table.R:826\n#, c-format\nmsgid \"\"\n\"'by' is a character vector length %d but one or more items include a comma. \"\n\"Either pass a vector of column names (which can contain spaces, but no \"\n\"commas), or pass a vector length 1 containing comma separated column names. \"\n\"See ?data.table for other possibilities.\"\nmsgstr \"\"\n\"'by' - это вектор из %d сток, но один или несколько элементов содержат \"\n\"запятую. Либо передайте вектор имен столбцов (который может содержать \"\n\"пробелы, но не запятые), либо передайте одну строку, содержащую имена \"\n\"столбцов, разделенные запятыми. Другие возможности см. в ?data.table.\"\n\n#: data.table.R:833\n#, c-format\nmsgid \"At least one entry of by is empty\"\nmsgstr \"Как минимум один элемент «by» пуст\"\n\n#: data.table.R:860\nmsgid \"by index '%s' but that index has 0 length. Ignoring.\"\nmsgstr \"«by» использовано с индексом '%s', но он нулевой длины. Пропускаю его.\"\n\n#: data.table.R:883\nmsgid \"i clause present and columns used in by detected, only these subset: %s\"\nmsgstr \"аргумент «i» использует следующие столбцы из «by»: %s\"\n\n#: data.table.R:886\nmsgid \"\"\n\"i clause present but columns used in by not detected. Having to subset all \"\n\"columns before evaluating 'by': '%s'\"\nmsgstr \"\"\n\"аргумент «i» не использует столбцы из «by». Вычисляю подмножество всех \"\n\"столбцов, прежде чем вычислить «by»: '%s'\"\n\n#: data.table.R:908\n#, c-format\nmsgid \"\"\n\"'by' appears to evaluate to column names but isn't c() or key(). Use \"\n\"by=list(...) if you can. Otherwise, by=eval%s should work. This is for \"\n\"efficiency so data.table can detect which columns are needed.\"\nmsgstr \"\"\n\"По-видимому, результатом вычисления «by» являются имена столбцов, но \"\n\"переданное выражение не является c() или key(). Пожалуйста, используйте \"\n\"by=list(...), если возможно. В противном случае подойдет by=eval%s. Это \"\n\"сделано для эффективности, чтобы data.table могла определить, какие столбцы \"\n\"нужны.\"\n\n#: data.table.R:919\n#, c-format\nmsgid \"\"\n\"'by' or 'keyby' must evaluate to a vector or a list of vectors (where 'list' \"\n\"includes data.table and data.frame which are lists, too)\"\nmsgstr \"\"\n\"Результатом вычисления «by» или «keyby» должен быть вектор или список \"\n\"векторов (что включает data.table и data.frame)\"\n\n#: data.table.R:923\n#, c-format\nmsgid \"\"\n\"Column or expression %d of 'by' or 'keyby' is type '%s' which is not \"\n\"currently supported. If you have a compelling use case, please add it to \"\n\"https://github.com/Rdatatable/data.table/issues/1597. As a workaround, \"\n\"consider converting the column to a supported type, e.g. by=sapply(list_col, \"\n\"toString), whilst taking care to maintain distinctness in the process.\"\nmsgstr \"\"\n\"Столбец или выражение №%d из «by» или «keyby» имеет тип '%s', который в \"\n\"настоящее время не поддерживается. Если у вас есть убедительный пример \"\n\"использования, пожалуйста, добавьте его на https://github.com/Rdatatable/\"\n\"data.table/issues/1597. Можно также попробовать преобразовать столбец к \"\n\"поддерживаемому типу, например by=sapply(list_col, toString), позаботившись \"\n\"при этом о сохранении различимости.\"\n\n#: data.table.R:951\nmsgid \"\"\n\"by-expression '%s' is not named, and the auto-generated name '%s' clashed \"\n\"with variable(s) in j. Therefore assigning the entire by-expression as name.\"\nmsgstr \"\"\n\"'by'-выражение '%s' не имеет имени, и автоматически придуманное имя '%s' \"\n\"пересекается со столбцами «j», так что использую выражение целиком в \"\n\"качестве его имени.\"\n\n#: data.table.R:985\n#, c-format\nmsgid \"Item %d of the .() or list() passed to j is missing\"\nmsgstr \"Пропущенный элемент №%d из .() или list(), переданного как «j»\"\n\n---\n\n```{r, test_id, message=FALSE, results=\"show\", echo=TRUE, warning=FALSE}\nrequire(data.table) # print?\nDT = data.table(x=1:3, y=4:6) # no\nDT # yes\nDT[, z := 7:9] # no\nprint(DT[, z := 10:12]) # yes\nif (1 < 2) DT[, a := 1L] # no\nDT # yes\n```\nSome text.\n\n---\n\nPara que data.table pueda heredar de `data.frame` sin usar `...`. Si usáramos `...`, no se detectarían los nombres de argumentos no válidos.\n\nEl argumento `drop` nunca se utiliza en `[.data.table`. Es un marcador de posición para paquetes que no son compatibles con data.table cuando usan la sintaxis `[.data.frame` directamente en un data.table.\n\n## ¡Las uniones continuas son geniales y rapidísimas! ¿Fue difícil programarlas?\n\nLa fila que prevalece en o antes de la fila `i` es la última fila que la búsqueda binaria prueba. Por lo tanto, `roll = TRUE` es básicamente un cambio en el código C de búsqueda binaria para devolver esa fila.\n\n## ¿Por qué `DT[i, col := value]` devuelve `DT` completo? Esperaba que no hubiera ningún valor visible (consistente con `<-`), o un mensaje o valor de retorno que indicara cuántas filas se actualizaron. No es evidente que los datos se hayan actualizado por referencia.\n\nEsto ha cambiado en la v1.8.3 para cumplir con sus expectativas. Actualice.\n\nSe devuelve la totalidad de `DT` (ahora de forma invisible) para que la sintaxis compuesta funcione; p. ej., `DT[i, done := TRUE][ , sum(done)]`. El número de filas actualizadas se devuelve cuando `verbose` es `TRUE`, ya sea por consulta o globalmente mediante `options(datatable.verbose = TRUE)`.\n\n## Bien, gracias. ¿Qué tenía de difícil que el resultado de `DT[i, col := valor]` se devolviera de forma invisible?\n\nR activa internamente la visibilidad para `[`. El valor de la columna eval de FunTab (ver [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) para `[` es `0`, lo que significa que se activa `R_Visible` (ver [R-Internals sección 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting)). Por lo tanto, al intentar `invisible()` o configurar `R_Visible` a `0` directamente, `eval` en [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) lo activaba de nuevo.\n\nPara solucionar este problema, la clave fue dejar de intentar detener la ejecución del método de impresión después de un `:=`. En su lugar, dentro de `:=` ahora (a partir de la v1.8.3) configuramos un indicador global que el método de impresión usa para determinar si imprimir o no.\n\n## ¿Por qué a veces tengo que escribir 'DT' dos veces después de usar ':=' para imprimir el resultado en la consola?\n\nEsta es una desventaja desafortunada para que [#869](https://github.com/Rdatatable/data.table/issues/869) funcione. Si se usa un `:=` dentro de una función sin `DT[]` antes del final de la función, la próxima vez que se escriba `DT` en el prompt, no se imprimirá nada. Un `DT` repetido se imprimirá. Para evitar esto: incluya un `DT[]` después del último `:=` en su función. Si eso no es posible (por ejemplo, no es una función que pueda cambiar), se garantiza que `print(DT)` y `DT[]` en el prompt se imprimirán. Como antes, agregar un `[]` adicional al final de la consulta `:=` es un modismo recomendado para actualizar y luego imprimir; por ejemplo, `DT[,foo:=3L][]`.\n\n## He observado que `base::cbind.data.frame` (y `base::rbind.data.frame`) parecen ser modificados por data.table. ¿Cómo es posible? ¿Por qué?\n\n---\n\n## Why `data.table`?\n\n* concise syntax: fast to type, fast to read\n* fast speed\n* memory efficient\n* careful API lifecycle management\n* community\n* feature rich\n\n## Features\n\n* fast and friendly delimited **file reader**: **[`?fread`](https://rdatatable.gitlab.io/data.table/reference/fread.html)**, see also [convenience features for _small_ data](https://github.com/Rdatatable/data.table/wiki/Convenience-features-of-fread)\n* fast and feature rich delimited **file writer**: **[`?fwrite`](https://rdatatable.gitlab.io/data.table/reference/fwrite.html)**\n* low-level **parallelism**: many common operations are internally parallelized to use multiple CPU threads\n* fast and scalable aggregations; e.g. 100GB in RAM (see [benchmarks](https://duckdblabs.github.io/db-benchmark/) on up to **two billion rows**)\n* fast and feature rich joins: **ordered joins** (e.g. rolling forwards, backwards, nearest and limited staleness), **[overlapping range joins](https://github.com/Rdatatable/data.table/wiki/talks/EARL2014_OverlapRangeJoin_Arun.pdf)** (similar to `IRanges::findOverlaps`), **[non-equi joins](https://github.com/Rdatatable/data.table/wiki/talks/ArunSrinivasanUseR2016.pdf)** (i.e. joins using operators `>, >=, <, <=`), **aggregate on join** (`by=.EACHI`), **update on join**\n* fast add/update/delete columns **by reference** by group using no copies at all\n* fast and feature rich **reshaping** data: **[`?dcast`](https://rdatatable.gitlab.io/data.table/reference/dcast.data.table.html)** (_pivot/wider/spread_) and **[`?melt`](https://rdatatable.gitlab.io/data.table/reference/melt.data.table.html)** (_unpivot/longer/gather_)\n* **any R function from any R package** can be used in queries not just the subset of functions made available by a database backend, also columns of type `list` are supported\n* has **[no dependencies](https://en.wikipedia.org/wiki/Dependency_hell)** at all other than base R itself, for simpler production/maintenance\n* the R dependency is **as old as possible for as long as possible**, currently R 3.5.0 (2018), and we continuously test against that version\n\n## Installation\n\n```r\ninstall.packages(\"data.table\")\n\n# latest development version (only if newer available)\ndata.table::update_dev_pkg()\n\n# latest development version (force install)\ninstall.packages(\"data.table\", repos=\"https://rdatatable.gitlab.io/data.table\")\n```\n\nSee [the Installation wiki](https://github.com/Rdatatable/data.table/wiki/Installation) for more details.\n\n## Usage\n\nUse `data.table` subset `[` operator the same way you would use `data.frame` one, but...\n\n* no need to prefix each column with `DT$` (like `subset()` and `with()` but built-in)\n* any R expression using any package is allowed in `j` argument, not just list of columns\n* extra argument `by` to compute `j` expression by group\n\n```r\nlibrary(data.table)\nDT = as.data.table(iris)\n\n# FROM[WHERE, SELECT, GROUP BY]\n# DT [i, j, by]\n\nDT[Petal.Width > 1.0, mean(Petal.Length), by = Species]\n# Species V1\n#1: versicolor 4.362791\n#2: virginica 5.552000\n```\n\n### Getting started\n\n* [Introduction to data.table](https://cran.r-project.org/package=data.table/vignettes/datatable-intro.html) vignette\n* [Getting started](https://github.com/Rdatatable/data.table/wiki/Getting-started) wiki page\n* [Examples](https://rdatatable.gitlab.io/data.table/reference/data.table.html#examples) produced by `example(data.table)`\n\n### Cheatsheets\n\n\n\n## Community\n\n---\n\n# in order as they're attached in a normal R session, to match that if these actually have an effect, e.g. under R_DEFAULT_PACKAGES=NULL\n# NB: pos= is required for these symbols to resolve searching 'upward' from data.table -- if these packages are not already attached,\n# and we don't use pos=, they'll wind up 'below' data.table on the search() path --> their symbols won't resolve since, when running\n# from the installed package, this is evaluated from data.table's namespace.\nif (\"include.only\" %in% names(formals(library))) { # TODO(R>=3.6.0): Remove this.\n libraryRobust = library\n} else {\n libraryRobust = function(..., include.only) library(...)\n}\nlibraryRobust(stats, include.only=c(\"lm\", \"median\", \"na.omit\", \"rnorm\", \"runif\", \"sd\", \"setNames\", \"var\", \"weighted.mean\"), pos=\"package:base\")\nlibraryRobust(utils, include.only=c(\"capture.output\", \"combn\", \"head\", \"read.csv\", \"read.delim\", \"read.table\", \"tail\", \"type.convert\", \"write.csv\", \"write.table\"), pos=\"package:base\")\nlibraryRobust(datasets, include.only=c(\"airquality\", \"BOD\", \"cars\", \"ChickWeight\", \"CO2\", \"iris\", \"mtcars\"), pos=\"package:base\")\n\nif (exists(\"test.data.table\", .GlobalEnv, inherits=FALSE)) {\n if ((tt<-compiler::enableJIT(-1))>0)\n cat(\"This is dev mode and JIT is enabled (level \", tt, \") so there will be a brief pause around the first test.\\n\", sep=\"\")\n rm_all = function() {}\n DTfun = DT ## otherwise DT would be re-defined by many tests\n} else {\n require(data.table)\n # Make symbols to the installed version's ::: so that we can i) test internal-only not-exposed R functions\n # in the test suite when user runs test.data.table() from installed package AND ii) so that in dev the same\n # tests can be used but in dev they test the package in .GlobalEnv. If we used ::: throughout tests, that\n # would pick up the installed version and in dev you'd have to reinstall every time which slows down dev.\n # NB: The string \"data.table::\" (which covers \"data.table:::\" too) should exist nowhere else in this file\n # other than here inside this branch.\n\n---\n\n## I have a question. I know the r-help posting guide tells me to contact the maintainer (not r-help), but is there a larger group of people I can ask?\nPlease see the [support guide](https://github.com/Rdatatable/data.table/wiki/Support) on the project's homepage which contains up-to-date links.\n\n## Where are the datatable-help archives?\nThe [homepage](https://github.com/Rdatatable/data.table/wiki) contains links to the archives in several formats.\n\n## I'd prefer not to post on the Issues page, can I mail just one or two people privately?\nSure. You're more likely to get a faster answer from the Issues page or Stack Overflow, though. Further, asking publicly in those places helps build the general knowledge base.\n\n## I have created a package that uses data.table. How do I ensure my package is data.table-aware so that inheritance from `data.frame` works?\n\nPlease see [this answer](https://stackoverflow.com/a/10529888/403310).\n\n```{r, echo=FALSE}\nsetDTthreads(.old.th)\n```\n\n---\n\n40. Following latest recommended testthat practices and to avoid a warning that it now issues, `inst/tests/testthat` has been moved to `/tests/testthat`. This means that testthat tests won't be installed for use by users by default and that `test_package(\"data.table\")` will now fail with error `No matching test file in dir` and also a warning `Placing tests in inst/tests/ is deprecated. Please use tests/testthat/ instead`. (That warning seems to be misleading since we already have made that move.) To install testthat tests (and this applies to all packages using testthat not just data.table) you need to follow the [deleted instructions](https://github.com/hadley/testthat/commit/0a7d27bb9ea545be7da1a10e511962928d888302) in testthat's README; i.e., reinstall data.table either with `--install-tests` passed to `R CMD INSTALL` or `INSTALL_opts = \"--install-tests\"` passed to `install.packages()`. After that, `test_package(\"data.table\")` will work. However, the main test suite of data.table (5,000+ tests) doesn't use testthat at all. Those tests are always installed so that `test.data.table()` can always be run by users at any time to confirm your installation on your platform is working correctly. Sometimes when supporting you, you may be asked to run `test.data.table()` and provide the output. Particularly now that data.table uses OpenMP. The file `/tests/tests.R` (which just calls `test.data.table()`) has been renamed to `/tests/main.R` to make this clearer to those looking at the GitHub repository and a comment has been added to `/tests/main.R` pointing to `/inst/tests/tests.Rraw` where those tests live. Some of these tests test data.table's compatibility with other packages and that is the reason those packages are listed in `DESCRIPTION:Suggests`. If you don't have some of those packages installed, `test.data.table()` will print output that it has skipped tests of compatibility with those packages. On CRAN all Suggests packages are available and data.table's tests of compatibility with them are tested by CRAN every day.\n\n 41. The license field is changed from \"GPL (>= 2)\" to \"GPL-3 | file LICENSE\" due to independent communication from two users of data.table at Google. The lack of an explicit license file was preventing them from contributing patches to data.table. Further, Google lawyers require the full text of the license and not a URL to the license. Since this requirement appears to require the choice of one license, we opted for GPL-3 and we checked the GPL-3 is fine by Google for them to use and contribute to. Accordingly, data.table's LICENSE file is an exact duplicate copy of the canonical GPL-3.\n\n 42. Thanks to @rrichmond for finding and reporting a regression in dev before release with `roll` not respecting fractions in type double, [#1904](https://github.com/Rdatatable/data.table/issues/1904). For example dates like `zoo::as.yearmon(\"2016-11\")` which is stored as `double` value 2016.833. Fixed and test added.\n\n\n## data.table v1.9.6 (on CRAN 19 Sep 2015)\n\n### NEW FEATURES\n\n---\n\n* Prettier printing of list columns. The first 6 items of atomic vectors\n are collapsed with \",\" followed by a trailing \",\" if there are more than\n 6, FR#1608. This difference to data.frame has been added to FAQ 2.17.\n Embedded objects (such as a data.table) print their class name only to avoid\n seemingly mangled output, bug #1803. Thanks to Yike Lu for reporting.\n For example:\n > data.table(x=letters[1:3],\n y=list( 1:10, letters[1:4], data.table(a=1:3,b=4:6) ))\n x y\n 1: a 1,2,3,4,5,6,\n 2: b a,b,c,d\n 3: c \n\n * Warnings added when joining character to factor, and factor to character.\n Character to character is now preferred in joins and needs no coercion.\n Even so, these coercions have been made much more efficient by taking\n a shallow copy of i internally, avoiding a full deep copy of i.\n\n * Ordered subsets now retain x's key. Always for logical and keyed i, using\n base::is.unsorted() for integer and unkeyed i. Implements FR#295.\n\n * mean() is now automatically optimized, #1231. This can speed up grouping\n by 20 times when there are a large number of groups. See wiki point 3, which\n is no longer needed to know. Turn off optimization by setting\n options(datatable.optimize=0).\n\n * DT[,lapply(.SD,...),by=...] is now automatically optimized, #2067. This can speed\n up applying a function by column by group, by over 20 times. See wiki point 5\n which is no longer needed to know. In other words:\n DT[,lapply(.SD,sum),by=grp]\n is now just as fast as :\n DT[,list(x=sum(x),y=sum(y)),by=grp]\n Don't forget to use .SDcols when a subset of columns is needed.\n\n * The package is now Byte Compiled (when installed in R 2.14.0 or later). Several\n internal speed improvements were made in this version too, such as avoiding\n internal copies. If you find 1.8.2 is faster, before attributing that to Byte\n Compilation, please install the package without Byte Compilation and compare\n ceteris paribus. If you find cases where speed has slowed, please let us know.\n\n * sapply(DT,class) gets a significant speed boost by avoiding a call to unclass()\n in as.list.data.table() called by lapply(DT,...), which copied the entire object.\n Thanks to a question by user1393348 on Stack Overflow, implementing #2000.\n https://stackoverflow.com/questions/10584993/r-loop-over-columns-in-data-table\n\n * The J() alias is now deprecated outside DT[...], but will still work inside\n DT[...], as in DT[J(...)].\n J() is conflicting with function J() in package XLConnect (#1747)\n and rJava (#2045). For data.table to change is easier, with some efficiency\n advantages too. The next version of data.table will issue a warning from J()\n when used outside DT[...]. The version after will remove it. Only then will\n the conflict with rJava and XLConnect be resolved.\n Please use data.table() directly instead of J(), outside DT[...].\n\n * New DT[.(...)] syntax (in the style of package plyr) is identical to\n DT[list(...)], DT[J(...)] and DT[data.table(...)]. We plan to add ..(), too, so\n that .() and ..() are analogous to the file system's ./ and ../; i.e., .()\n evaluates within the frame of DT and ..() in the parent scope.\n\n * New function rbindlist(l). This does the same as do.call(\"rbind\",l), but much\n faster.\n\n### BUG FIXES\n\n * DT[,f(.SD),by=colA] where f(x)=x[,colB:=1L] was a segfault, bug#1727.\n This is now a graceful error to say that using := in .SD's j is\n reserved for future use. This was already caught in most circumstances,\n other than via f(.SD). Thanks to Leon Baum for reporting. Test added.", "answer": "In simple terms, **`data.table`** is an R package used for handling tabular data (data organized in rows and columns). It is an **enhanced version** of the standard R `data.frame`.\n\nIf you are familiar with spreadsheets or standard R data frames, here is why `data.table` is different:\n\n### 1. The Core Syntax: `DT[i, j, by]`\nThe most important thing to learn is its \"general form.\" You can perform most tasks using this simple structure:\n* **`i` (Where/Order by):** Which rows do you want? (e.g., \"all flights from JFK\").\n* **`j` (Select/Update):** What do you want to do to the columns? (e.g., \"calculate the average delay\").\n* **`by` (Group by):** How do you want to group the data? (e.g., \"grouped by each airline\").\n\n**Think of it like this:** Take `DT`, subset/reorder rows using `i`, then calculate `j`, grouped by `by`.\n\n### 2. Why use it?\n* **Speed and Efficiency:** It is designed to be incredibly fast, even with very large datasets (e.g., 100GB in RAM).\n* **Concise Syntax:** It allows you to do a lot of work with very little typing, which makes your code easier to read once you learn the basics.\n* **Memory Efficient:** It can modify data \"by reference,\" meaning it updates your table directly without making unnecessary, memory-hungry copies.\n\n### 3. It plays well with others\nBecause `data.table` **inherits** from `data.frame`, it is compatible with almost all R functions and packages that expect a standard `data.frame`. You don't have to choose one or the other; you can use `data.table` alongside your other favorite R tools.\n\n### A Quick Example\nIf you have a table called `flights`, and you want to find the average delay for each origin airport, the code looks like this:\n\n```r\nflights[, mean(dep_delay), by = origin]\n```\n\nTo get started, you can simply type `vignette(\"datatable-intro\", package=\"data.table\")` in your R console.", "source_count": 100, "source_metadata": [{"source": "data.table", "file_name": "README.md", "file_path": "README.md", "id": "3c4fe1a2582b4ed59bb52ebc1b9b65a8", "project": "data.table"}, {"file_name": "Seal_of_Approval.md", "id": "96dd04b8ec0442dbbd4b9dc31970e012", "source": "data.table", "file_path": "Seal_of_Approval.md", "project": "data.table"}, {"file_name": "DESCRIPTION", "id": "c5ab43047d0d422ba5c2df6445a21e21", "project": "data.table", "file_path": "DESCRIPTION", "source": "data.table"}, {"file_path": "vignettes\\datatable-importing.Rmd", "id": "d6dc0ec821c4422db80cf97d005f6124", "project": "data.table", "file_name": "datatable-importing.Rmd", "source": "data.table"}, {"id": "32e8c1a9870a47b7900cfaae98ce748b", "source": "data.table.wiki", "project": "data.table"}, {"id": "2b4dfd575daa49329c5d1d23412e93a9", "file_name": "GOVERNANCE.md", "file_path": "GOVERNANCE.md", "project": "data.table", "source": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "5888c9a5cbd944759795b8646586ee51"}, {"file_name": "data.table.Rd", "id": "b13d53994c0d4b86ac2d726d65efc14d", "source": "data.table", "project": "data.table", "file_path": "man\\data.table.Rd"}, {"file_name": "datatable-importing.Rmd", "file_path": "vignettes\\datatable-importing.Rmd", "project": "data.table", "source": "data.table", "id": "d97a1b458ea04da895070cb4114e37af"}, {"project": "data.table", "id": "e28722b7d04643799f61862fe062af00", "file_name": "datatable-importing.Rmd", "source": "data.table", "file_path": "vignettes\\datatable-importing.Rmd"}, {"id": "b39d7dfd78e0404488f046ebc1bb4351", "file_name": "data.table-win.def", "project": "data.table", "file_path": "src\\data.table-win.def", "source": "data.table"}, {"file_path": "vignettes\\fr\\datatable-importing.Rmd", "source": "data.table", "file_name": "datatable-importing.Rmd", "project": "data.table", "id": "3d8247b228794497a2c33b0c496067ea"}, {"file_path": "NEWS.0.md", "project": "data.table", "id": "dae2a8ad93764d51bf8859b8cab1334e", "source": "data.table", "file_name": "NEWS.0.md"}, {"id": "e627d1c447b742578dac702a6ffb547b", "project": "data.table", "source": "data.table", "file_path": "vignettes\\fr\\datatable-importing.Rmd", "file_name": "datatable-importing.Rmd"}, {"source": "data.table.wiki", "id": "f89d58fa619f4c7d82f078d086303653", "project": "data.table"}, {"id": "c7963258d5dd4678bb4fea2138fec5ca", "project": "data.table", "source": "data.table", "file_name": "tables.Rd", "file_path": "man\\tables.Rd"}, {"file_path": "vignettes\\datatable-intro.Rmd", "id": "c59973a6e616456b90171bf90b59a216", "project": "data.table", "file_name": "datatable-intro.Rmd", "source": "data.table"}, {"project": "data.table", "id": "64f5109f50f4434dbf105465c7c7993f", "source": "data.table.wiki"}, {"file_path": "vignettes\\es\\datatable-importing.Rmd", "file_name": "datatable-importing.Rmd", "id": "4fc4fd3d640e44e081604ce6154fb71b", "source": "data.table", "project": "data.table"}, {"source": "data.table", "project": "data.table", "file_name": "R-pt_BR.po", "id": "890a502b54c14bef8dae6116fecf9b8a", "file_path": "po\\R-pt_BR.po"}, {"project": "data.table", "file_path": "vignettes\\datatable-sd-usage.Rmd", "source": "data.table", "id": "0ca33a9d7ad346e09dda76d4bea9e861", "file_name": "datatable-sd-usage.Rmd"}, {"project": "data.table", "source": "data.table", "id": "ea975b8f9def4ff080d65f9b1fa88a48", "file_path": "vignettes\\fr\\datatable-faq.Rmd", "file_name": "datatable-faq.Rmd"}, {"id": "e4647882f8584c6da6aca1041fabe80a", "source": "data.table.wiki", "project": "data.table"}, {"project": "data.table", "source": "data.table.wiki", "id": "6932435f68c848d1b616e5695cc39dda"}, {"file_path": "NEWS.0.md", "project": "data.table", "file_name": "NEWS.0.md", "id": "e086a585719a425c955026555e249a3c", "source": "data.table"}, {"file_name": "S4.R", "project": "data.table", "file_path": "tests\\S4.R", "source": "data.table", "id": "2be434b6071545ec961bce14643bac86"}, {"project": "data.table", "source": "data.table", "file_name": "datatable-importing.Rmd", "file_path": "vignettes\\datatable-importing.Rmd", "id": "1fe25cacaadd4e62846696630dfa339b"}, {"file_path": "po\\R-es.po", "project": "data.table", "file_name": "R-es.po", "source": "data.table", "id": "5bccfcabcae74a6497f189c9d29b6e1f"}, {"project": "data.table", "source": "data.table.wiki", "id": "8764c4f90fe44d76bca0481224b6fdda"}, {"file_name": "data.table.R", "source": "data.table", "file_path": "R\\data.table.R", "id": "3b90a8ea608d41338e48a21884c57c09", "project": "data.table"}, {"project": "data.table", "source": "data.table", "id": "272206e706434c71a3d9c24508052785", "file_name": "datatable-intro.Rmd", "file_path": "vignettes\\ru\\datatable-intro.Rmd"}, {"source": "data.table.wiki", "project": "data.table", "id": "958fb36e09c24b7db81eb357fb224e0e"}, {"file_path": "tests\\programming.R", "id": "56df889d74014bd8a80ccfa093fdb8cb", "project": "data.table", "file_name": "programming.R", "source": "data.table"}, {"file_name": "autoprint.Rout.save", "project": "data.table", "id": "c370cc8babaf4482ab4b3cd379aecd5c", "source": "data.table", "file_path": "tests\\autoprint.Rout.save"}, {"project": "data.table", "file_path": "vignettes\\datatable-importing.Rmd", "file_name": "datatable-importing.Rmd", "id": "b85a8fd3759e4a56a43e4fa3c6dc06bf", "source": "data.table"}, {"file_path": "po\\R-ru.po", "id": "f257cef0513b4a94a5b8397fb3d11e5a", "file_name": "R-ru.po", "source": "data.table", "project": "data.table"}, {"file_name": "datatable-importing.Rmd", "file_path": "vignettes\\fr\\datatable-importing.Rmd", "id": "0cbc60c1e0b84adbb4d794cd545af9f7", "project": "data.table", "source": "data.table"}, {"file_name": "datatable-importing.Rmd", "file_path": "vignettes\\fr\\datatable-importing.Rmd", "source": "data.table", "project": "data.table", "id": "d6b011e6d2a34013a9fb3508026373d3"}, {"file_name": "NEWS.0.md", "file_path": "NEWS.0.md", "id": "ca4d798589af491baf7f829ed633fc46", "source": "data.table", "project": "data.table"}, {"id": "762bfb142a0942ed830d525c1eb2b3a4", "file_path": "R\\data.table.R", "file_name": "data.table.R", "project": "data.table", "source": "data.table"}, {"project": "data.table", "file_path": "vignettes\\es\\datatable-importing.Rmd", "source": "data.table", "file_name": "datatable-importing.Rmd", "id": "1708719cf80e40c994394abee5c19834"}, {"file_path": "vignettes\\fr\\datatable-faq.Rmd", "source": "data.table", "id": "d605a34ddf8144bd85b9d02f2bc5dd4e", "project": "data.table", "file_name": "datatable-faq.Rmd"}, {"source": "data.table", "file_path": "src\\wrappers.c", "file_name": "wrappers.c", "id": "f15d564c57624b92bde5a39c3d2d1653", "project": "data.table"}, {"file_name": "NEWS.md", "project": "data.table", "file_path": "NEWS.md", "source": "data.table", "id": "9d3c370b49c94db0a8f1d38f9c04e012"}, {"project": "data.table", "file_name": "NEWS.md", "source": "data.table", "file_path": "NEWS.md", "id": "aac79ec753d243e9bb8e2c518290b6e1"}, {"file_name": "melt.data.table.Rd", "project": "data.table", "file_path": "man\\melt.data.table.Rd", "source": "data.table", "id": "e9550ba8f44f4373945e1e89f092c2d5"}, {"id": "e85dca8179784f35b8f1d1f1fa96974a", "source": "data.table.wiki", "project": "data.table"}, {"project": "data.table", "id": "172f3704f3654961835b0ab4fab4fd0d", "file_path": "vignettes\\datatable-faq.Rmd", "source": "data.table", "file_name": "datatable-faq.Rmd"}, {"id": "29e043e15c9d4120b442b29ef94ad07a", "project": "data.table", "source": "data.table", "file_name": "coalesce.c", "file_path": "src\\coalesce.c"}, {"project": "data.table", "id": "446cfa5a99104b0294e30e25dd2232d2", "source": "data.table", "file_name": "cj.c", "file_path": "src\\cj.c"}, {"id": "8a48be0be63c4358826c6825cdc996ac", "source": "data.table", "file_path": "NEWS.0.md", "file_name": "NEWS.0.md", "project": "data.table"}, {"file_name": "NEWS.1.md", "project": "data.table", "id": "2959c644c31f4a2c8d2dd4210648fe73", "source": "data.table", "file_path": "NEWS.1.md"}, {"id": "eddd9f6241fc494aac9a400c3cb1d314", "source": "data.table", "file_path": "vignettes\\datatable-faq.Rmd", "file_name": "datatable-faq.Rmd", "project": "data.table"}, {"file_path": "NEWS.1.md", "project": "data.table", "id": "04b26ef9989a4b01af236dce67550620", "file_name": "NEWS.1.md", "source": "data.table"}, {"file_path": "NEWS.1.md", "source": "data.table", "id": "2ba9f017369b41a2836e0bb0a22c76af", "project": "data.table", "file_name": "NEWS.1.md"}, {"file_name": "options_documentation_linter.R", "project": "data.table", "file_path": ".ci\\linters\\rd\\options_documentation_linter.R", "source": "data.table", "id": "e2b7f93238164eea8acc239ffacbbe1d"}, {"file_name": "cdt.Rd", "project": "data.table", "source": "data.table", "id": "7c0d74abf4d8445981269148436ceda8", "file_path": "man\\cdt.Rd"}, {"source": "data.table", "project": "data.table", "file_name": "datatable-faq.Rmd", "file_path": "vignettes\\fr\\datatable-faq.Rmd", "id": "7845c3e8bf054557938399888ebf6e25"}, {"id": "2b0e0d4853bb4659bed8c87d6402c7bd", "file_name": "datatable-importing.Rmd", "project": "data.table", "source": "data.table", "file_path": "vignettes\\datatable-importing.Rmd"}, {"file_path": "src\\po.h", "file_name": "po.h", "source": "data.table", "id": "de28b8f028de46e7bee24f8831e17b15", "project": "data.table"}, {"id": "afea17444efa4ca9b70a668c1a8d6349", "source": "data.table", "file_path": "vignettes\\fr\\datatable-importing.Rmd", "file_name": "datatable-importing.Rmd", "project": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "b04346cf0eb9475faf3b3e570071ff55"}, {"source": "data.table", "file_path": "po\\R-fr.po", "file_name": "R-fr.po", "project": "data.table", "id": "2aec2a56ff82481491a3fbae58f063e1"}, {"source": "data.table", "file_path": "NEWS.1.md", "file_name": "NEWS.1.md", "id": "7963a37b46104633a477272aaf769caa", "project": "data.table"}, {"project": "data.table", "id": "6337134f41b641ebaef0fb4e03e10320", "source": "data.table", "file_name": "NEWS.md", "file_path": "NEWS.md"}, {"file_name": "datatable-intro.Rmd", "project": "data.table", "id": "7d082cfc6ca445adbd65f48162acd502", "file_path": "vignettes\\fr\\datatable-intro.Rmd", "source": "data.table"}, {"file_path": "vignettes\\datatable-reference-semantics.Rmd", "project": "data.table", "file_name": "datatable-reference-semantics.Rmd", "id": "d1b44da9bcb14e2d9b971b0483ee8a08", "source": "data.table"}, {"project": "data.table", "file_name": "IDateTime.Rd", "file_path": "man\\IDateTime.Rd", "id": "e5f9a3c717b14e29972bf98a0f18bb02", "source": "data.table"}, {"file_path": "vignettes\\es\\datatable-importing.Rmd", "source": "data.table", "file_name": "datatable-importing.Rmd", "id": "62cc00e2a4784b19963dcbf21303756d", "project": "data.table"}, {"file_path": "inst\\tests\\nafill.Rraw", "file_name": "nafill.Rraw", "project": "data.table", "source": "data.table", "id": "768b550f604d4155b739a6e414a18153"}, {"id": "4636114d3ff043a3b95d5b1a8ee2b834", "project": "data.table", "file_path": "NEWS.md", "file_name": "NEWS.md", "source": "data.table"}, {"project": "data.table", "id": "066c2f1e742d4436b4a69f442a0c18b6", "source": "data.table", "file_name": "NEWS.0.md", "file_path": "NEWS.0.md"}, {"project": "data.table", "file_name": "types.R", "source": "data.table", "file_path": "tests\\types.R", "id": "60da12cdd25a46baa15fd77dcdf29546"}, {"id": "516b05fc83294d91acb417756d056f43", "source": "data.table", "file_path": "po\\R-fr.po", "project": "data.table", "file_name": "R-fr.po"}, {"project": "data.table", "source": "data.table.wiki", "id": "a022b787c385401cbf27faf52d546073"}, {"file_name": "datatableAPI.h", "source": "data.table", "file_path": "inst\\include\\datatableAPI.h", "project": "data.table", "id": "55d01c21065b489baaa689a233ac3e20"}, {"id": "87431596d51346199c4ccb903571c01d", "project": "data.table", "file_name": "NEWS.md", "file_path": "NEWS.md", "source": "data.table"}, {"file_name": "NEWS.md", "project": "data.table", "file_path": "NEWS.md", "id": "906e5b359d5a4b28bcd53c4501747ced", "source": "data.table"}, {"project": "data.table", "source": "data.table", "file_name": "tests.Rraw", "id": "77beaf30ea0c4e68aa40a34ec8592d3e", "file_path": "inst\\tests\\tests.Rraw"}, {"file_path": "vignettes\\datatable-programming.Rmd", "project": "data.table", "file_name": "datatable-programming.Rmd", "id": "d5afbe2dbe2547ffa77884e1092b2bf8", "source": "data.table"}, {"id": "887a4286d5414d59adb7e6d34dfee4e0", "project": "data.table", "file_name": "datatable-faq.Rmd", "file_path": "vignettes\\datatable-faq.Rmd", "source": "data.table"}, {"id": "a011459d552d410bbe168f1338801249", "source": "data.table", "project": "data.table", "file_path": "inst\\tests\\knitr.Rmd", "file_name": "knitr.Rmd"}, {"source": "data.table", "id": "599e7364cea24a1eb387b24999f3e94e", "project": "data.table", "file_name": "NEWS.0.md", "file_path": "NEWS.0.md"}, {"project": "data.table", "file_path": "NEWS.1.md", "source": "data.table", "id": "bd6b4e7000274e739eea97ac7f5b54c6", "file_name": "NEWS.1.md"}, {"file_name": "datatable-reference-semantics.Rmd", "source": "data.table", "project": "data.table", "file_path": "vignettes\\datatable-reference-semantics.Rmd", "id": "ef51701dd9d44fe8b8e8f30c33c5b1bc"}, {"id": "5800f811b30d4c34b9a96fc9ec37dbb4", "project": "data.table", "source": "data.table", "file_path": ".ci\\atime\\tests.R", "file_name": "tests.R"}, {"source": "data.table", "file_path": "inst\\tests\\optimize.Rraw", "file_name": "optimize.Rraw", "id": "9fdfa51a4782414699810b1531c1dee8", "project": "data.table"}, {"file_path": ".github\\CONTRIBUTING.md", "id": "4fab07e5a1aa417db93d1a647cb8e606", "file_name": "CONTRIBUTING.md", "project": "data.table", "source": "data.table"}, {"file_name": "print.data.table.R", "source": "data.table", "project": "data.table", "file_path": "R\\print.data.table.R", "id": "8b7840063f8d4caa9e786febd5cdd7bd"}, {"project": "data.table", "id": "bc0b435c15af482083aa306adfd563c1", "file_name": "data.table.R", "source": "data.table", "file_path": "R\\data.table.R"}, {"project": "data.table", "source": "data.table", "file_path": "NEWS.0.md", "id": "182be49a1d4c41fea09b321330087992", "file_name": "NEWS.0.md"}, {"file_name": "tests.Rraw", "id": "28a6fd27dac74723ab14b3e4bb816034", "source": "data.table", "project": "data.table", "file_path": "inst\\tests\\tests.Rraw"}, {"file_name": "R-ru.po", "project": "data.table", "source": "data.table", "id": "14cca12cd61a45ccb8789dfa3a46d0e2", "file_path": "po\\R-ru.po"}, {"source": "data.table", "id": "a5703f4431964b2db6897684e75c1c1f", "project": "data.table", "file_path": "tests\\litedown.Rmd", "file_name": "litedown.Rmd"}, {"project": "data.table", "file_name": "datatable-faq.Rmd", "source": "data.table", "id": "ee3c8d98a7464061a751cdeed58cd3f5", "file_path": "vignettes\\es\\datatable-faq.Rmd"}, {"id": "0e2d7abd759a44bdb3f790a2406b8e5a", "file_path": "README.md", "file_name": "README.md", "project": "data.table", "source": "data.table"}, {"file_path": "inst\\tests\\tests.Rraw", "source": "data.table", "file_name": "tests.Rraw", "id": "f48948c2ba574248a2216d81aa7c003b", "project": "data.table"}, {"project": "data.table", "source": "data.table", "id": "4e0cf466e83646dfb151e66fb1986491", "file_name": "datatable-faq.Rmd", "file_path": "vignettes\\datatable-faq.Rmd"}, {"source": "data.table", "file_name": "NEWS.0.md", "id": "4254bd57a96c44efa3f3ad8c6baec490", "project": "data.table", "file_path": "NEWS.0.md"}, {"file_name": "NEWS.0.md", "file_path": "NEWS.0.md", "project": "data.table", "source": "data.table", "id": "82c10685280f4eb8b3ec3ce37e3ca643"}]} -{"timestamp": "2026-02-11T12:08:58", "session_id": "1471221413766627340", "question": "tell me about data table", "retrieved_context": "HTML vignettes\n\nIntroduction to data.table\n\nReference semantics\n\nKeys and fast binary search based subsets\n\nSecondary indices and auto indexing\n\nEfficient reshaping using data.tables\n\nFrequently asked questions\n\nDocumentation and examples\n\n?data.table\n\n?fread\n\npdf manual\n\ndevel html manual\n\ncheat sheet\n\nin-depth tables tutorial\n\nQuestions & Answers\n\ncommunity support on data.table stackoverflow tag\n\nRead [[Support]] wiki on how to properly ask questions and additional information about support.\n\nNotices/discussion\n\nFollow #rdatatable\n\nClick the 'watch' button at the top and right of this page (next to star and fork)\n\nUser reviews\n\nCrantastic\n\nLearn by doing\n\ndata.table course on DataCamp\n\n---\n\nProvide an external link to the minimal reproducible file and use that file name in your code.\n\nLook at closed issues. Observe the good and the bad.\n\nType ?data.table and look at all the arguments. Do you know them all? For example, do you know which= and others? Make sure you do. It is likely that one of them is there for your task. If some seem like they could help, search Stack Overflow for that argument name within the [data.table] tag and see how people have used it. Many answers use data.table but the question was not about data.table, so in this situation search in the [r] tag (not [data.table]) for the \"data.table\" and the argument name.\n\nRead all the vignettes.\n\nRead all the questions in the data.table FAQ even if you don't have those questions yet.\n\nTake the Datacamp course\n\nBest wishes!\n\n---\n\n## Community\n\n`data.table` is widely used by the R community. It is being directly used by hundreds of CRAN and Bioconductor packages, and indirectly by thousands. It is one of the [top most starred](https://medium.datadriveninvestor.com/most-starred-and-forked-github-repos-for-r-in-data-science-fb87a54d2a6a) R packages on GitHub, and was highly rated by the [Depsy project](http://depsy.org/package/r/data.table). If you need help, the `data.table` community is active on [StackOverflow](https://stackoverflow.com/questions/tagged/data.table).\n\nA list of packages that significantly support, extend, or make use of `data.table` can be found in the [Seal of Approval](https://github.com/Rdatatable/data.table/blob/master/Seal_of_Approval.md) document.\n\n### Stay up-to-date\n\n- click the **Watch** button at the top and right of GitHub project page\n- read [NEWS file](https://github.com/Rdatatable/data.table/blob/master/NEWS.md)\n- follow [#rdatatable](https://x.com/hashtag/rdatatable) and the [r_data_table](https://x.com/r_data_table) account on X/Twitter\n- follow [#rdatatable](https://fosstodon.org/tags/rdatatable) and the [r_data_table account](https://fosstodon.org/@r_data_table) on fosstodon\n- follow the [data.table community page](https://www.linkedin.com/company/data-table-community) on LinkedIn\n- watch recent [Presentations](https://github.com/Rdatatable/data.table/wiki/Presentations)\n- read recent [Articles](https://github.com/Rdatatable/data.table/wiki/Articles)\n- read posts on [The Raft](https://rdatatable-community.github.io/The-Raft/)\n\n### Contributing\n\nGuidelines for filing issues / pull requests: [Contribution Guidelines](https://github.com/Rdatatable/data.table/blob/master/.github/CONTRIBUTING.md).\n\n---\n\n![Grouping, Illustrated](plots/grouping_illustration.png)\n\n\nIn the case of grouping, `.SD` is multiple in nature -- it refers to _each_ of these sub-`data.table`s, _one-at-a-time_ (slightly more accurately, the scope of `.SD` is a single sub-`data.table`). This allows us to concisely express an operation that we'd like to perform on _each sub-`data.table`_ before the re-assembled result is returned to us.\n\nThis is useful in a variety of settings, the most common of which are presented here:\n\n## Group Subsetting\n\nLet's get the most recent season of data for each team in the Lahman data. This can be done quite simply with:\n\n```{r group_sd_last}\n# the data is already sorted by year; if it weren't\n# we could do Teams[order(yearID), .SD[.N], by = teamID]\nTeams[ , .SD[.N], by = teamID]\n```\n\nRecall that `.SD` is itself a `data.table`, and that `.N` refers to the total number of rows in a group (it's equal to `nrow(.SD)` within each group), so `.SD[.N]` returns the _entirety of `.SD`_ for the final row associated with each `teamID`.\n\nAnother common version of this is to use `.SD[1L]` instead to get the _first_ observation for each group, or `.SD[sample(.N, 1L)]` to return a _random_ row for each group.\n\n## Group Optima\n\nSuppose we wanted to return the _best_ year for each team, as measured by their total number of runs scored (`R`; we could easily adjust this to refer to other metrics, of course). Instead of taking a _fixed_ element from each sub-`data.table`, we now define the desired index _dynamically_ as follows:\n\n```{r sd_team_best_year}\nTeams[ , .SD[which.max(R)], by = teamID]\n```\n\nNote that this approach can of course be combined with `.SDcols` to return only portions of the `data.table` for each `.SD` (with the caveat that `.SDcols` should be fixed across the various subsets).\n\n_NB_: `.SD[1L]` is currently optimized by [_`GForce`_](https://Rdatatable.gitlab.io/data.table/library/data.table/html/datatable-optimize.html) ([see also](https://stackoverflow.com/questions/22137591/about-gforce-in-data-table-1-9-2)), `data.table` internals which massively speed up the most common grouped operations like `sum` or `mean` -- see `?GForce` for more details and keep an eye on/voice support for feature improvement requests for updates on this front: [1](https://github.com/Rdatatable/data.table/issues/735), [2](https://github.com/Rdatatable/data.table/issues/2778), [3](https://github.com/Rdatatable/data.table/issues/523), [4](https://github.com/Rdatatable/data.table/issues/971), [5](https://github.com/Rdatatable/data.table/issues/1197), [6](https://github.com/Rdatatable/data.table/issues/1414).\n\n## Grouped Regression\n\nReturning to the inquiry above regarding the relationship between `ERA` and `W`, suppose we expect this relationship to differ by team (i.e., there's a different slope for each team). We can easily re-run this regression to explore the heterogeneity in this relationship as follows (noting that the standard errors from this approach are generally incorrect -- the specification `ERA ~ W*teamID` will be better -- this approach is easier to read and the _coefficients_ are OK):\n\n---\n\nInstead, in *data.tables* we set and use `keys`. Think of a `key` as **supercharged rownames**.\n\n#### Keys and their properties {#key-properties}\n\n1. We can set keys on *multiple columns* and the column can be of *different types* -- *integer*, *numeric*, *character*, *factor*, *integer64* etc. *list* and *complex* types are not supported yet.\n\n2. Uniqueness is not enforced, i.e., duplicate key values are allowed. Since rows are sorted by key, any duplicates in the key columns will appear consecutively.\n\n3. Setting a `key` does *two* things:\n\n a. physically reorders the rows of the *data.table* by the column(s) provided *by reference*, always in *increasing* order.\n\n b. marks those columns as *key* columns by setting an attribute called `sorted` to the *data.table*.\n\n Since the rows are reordered, a *data.table* can have at most one key because it can not be sorted in more than one way.\n\nFor the rest of the vignette, we will work with `flights` data set.\n\n### b) Set, get and use keys on a *data.table*\n\n#### -- How can we set the column `origin` as key in the *data.table* `flights`?\n\n```{r}\nsetkey(flights, origin)\nhead(flights)\n\n## alternatively we can provide character vectors to the function 'setkeyv()'\n# setkeyv(flights, \"origin\") # useful to program with\n```\n\n* You can use the function `setkey()` and provide the column names (without quoting them). This is helpful during interactive use.\n\n* Alternatively you can pass a character vector of column names to the function `setkeyv()`. This is particularly useful while designing functions to pass columns to set key on as function arguments.\n\n* Note that we did not have to assign the result back to a variable. This is because like the `:=` function we saw in the [`vignette(\"datatable-reference-semantics\", package=\"data.table\")`](datatable-reference-semantics.html) vignette, `setkey()` and `setkeyv()` modify the input *data.table* *by reference*. They return the result invisibly.\n\n* The *data.table* is now reordered (or sorted) by the column we provided - `origin`. Since we reorder by reference, we only require additional memory of one column of length equal to the number of rows in the *data.table*, and is therefore very memory efficient.\n\n* You can also set keys directly when creating *data.tables* using the `data.table()` function using `key` argument. It takes a character vector of column names.\n\n#### set* and `:=`:\n\nIn *data.table*, the `:=` operator and all the `set*` (e.g., `setkey`, `setorder`, `setnames` etc.) functions are the only ones which modify the input object *by reference*.\n\nOnce you *key* a *data.table* by certain columns, you can subset by querying those key columns using the `.()` notation in `i`. Recall that `.()` is an *alias to* `list()`.\n\n#### -- Use the key column `origin` to subset all rows where the origin airport matches *\"JFK\"*\n\n```{r}\nflights[.(\"JFK\")]\n\n## alternatively\n# flights[J(\"JFK\")] (or)\n# flights[list(\"JFK\")]\n```\n\n* The *key* column has already been set to `origin`. So it is sufficient to provide the value, here *\"JFK\"*, directly. The `.()` syntax helps identify that the task requires looking up the value *\"JFK\"* in the key column of *data.table* (here column `origin` of `flights` *data.table*).\n\n* The *row indices* corresponding to the value *\"JFK\"* in `origin` is obtained first. And since there is no expression in `j`, all columns corresponding to those row indices are returned.\n\n* On single column key of *character* type, you can drop the `.()` notation and use the values directly when subsetting, like subset using row names on *data.frames*.\n\n ```r\n flights[\"JFK\"] ## same as flights[.(\"JFK\")]\n ```\n\n* We can subset any amount of values as required\n\n ```r\n flights[c(\"JFK\", \"LGA\")] ## same as flights[.(c(\"JFK\", \"LGA\"))]\n ```\n\n This returns all columns corresponding to those rows where `origin` column matches either *\"JFK\"* or *\"LGA\"*.\n\n---\n\n2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk\n\n2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse\n\n2019.07 : Bayesian analysis with Stan & Data manipulation with data.table, Jared Kai Swan, Los Angeles East\n\n2019.07 : Start using data.table, Megan Stodel, Ministry of Justice Coffee and Coding\n\n2019.07 : Wrangling 4.6M rows of Financial Data (Home Loans Time Series) in R with data.table, Matt Dancho, Business Science Learning Lab\n\n2019.07 : data.table: a slide deck of data.table piping Gina Reynolds, slides\n\n2019.06 : why data.table?, Jan Gorecki, Poznan R User Group\n\n2019.05 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O Meetup Mountain View\n\n2019.05 : Workshop: Getting Started in R and data.table - Saghir Bashir, ilustat.com\n\n2019.04 : Pipes or Brackets: dplyr and data.table, Jeremy Guinta & Amy Linehan, satRday LA\n\n2019.02 : Machine Learning and Data Munging in H2O Driverless AI with datatable, Pasha Stetsenko & Oleksiy Kononenko, H2O World San Francisco\n\n2019.01 : Introduction to Automatic and Scalable Machine Learning with H2O and R (afternoon session data.table), Dmytro Perepolkin and Raoul Wolf, University of Oslo Library\n\n2018.12 : Workshop: Getting Started in R and data.table, Saghir Bashir, Data Science Unplugged Lisbon\n\n2018.10 : data.table for R, Python and updated-daily benchmarks, Matt Dowle, H2OWorld London\n\n2018.09 : Life in the Fast Lane: data.table Intro and Best Practices, Bill Gold, New York OSPM\n\n2018.09 : ALTREP from a data.table perspective, Matt Dowle, DSC Stanford I talked ad-lib and showed code on screen; no slides.\n\n2018.09 : Tutorial: efficient data manipulation with data.table, Jaap Walhout, uRos The Hague\n\n2018.08 : Success with OpenMP in R package data.table, Matt Dowle, JSM Vancouver\n\n2018.07 : 12 years of data.table (past, present and future), Arun Srinivasan, R in Montreal\n\n2018.07 : What's new in data.table, Jan Gorecki, WhyR Wroclaw\n\n2018.06 : Data munging in driverless.ai with datatable, Pasha Stetsenko, H2OWorld New York\n\n2018.05 : Top 10 reasons to use data.table; O Jossome, T Robert and F Meyer, dreamRs 2018\n\n2018.05 : The beauty of data manipulation with data.table, János Divényi, eRum Budapest\n\n2017.12 : data.table, Matt Dowle, H2O World Mountain View\n\n2017.11 : data.table, Sebastian Jeworutzki, useR! Bochum\n\n2017.07 : data.table for beginners (tutorial), Arun Srinivasan, useR! Brussels\n\n2017.04 : Parallel fread and other news from data.table, Matt Dowle, Bay Area RUG\n\n2017.04 : data.table power hour, Steph Locke, SQLBits London\n\n2017.01 : New developments in the data.table package, Arun Srinivasan, AmstRdam RUG\n\n2016.09 : Data manipulation the #rdatatable way, Arun Srinivasan, SatRdays Budapest\n\n2016.07 : Parallel and distributed ordered join benchmark, Matt Dowle, H2O Open Tour New York\n\n2016.07 : Proposal for parallel sort in base R (and Python/Julia), Matt Dowle, DSC Stanford\n\n2016.06 : Efficient in-memory non-equi joins, Arun Srinivasan, useR! Stanford\n\n2016.06 : Ninja Moves with data.table 3hr tutorial, Matt Dowle & Arun Srinivasan, useR! Stanford\n\n2016.05 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin\n\n2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, Data by the Bay San Francisco\n\n2016.05 : Parallel and Distributed Joins in H2O, Matt Dowle, H2O Open Tour Chicago\n\n2016.05 : R Lecture #3: data.table, Peter Hurford\n\n2016.02 Data Science Retreat, 3-day data.table course, Arun Srinivasan, DSR Berlin\n\n2016.02 Parallel and Distributed Joining, Matt Dowle, Bay Area R User Group\n\n2016.01 Invited lecture by Matt Dowle at Stat290 Paradigms for Computing with Data, Stanford\n\n2016.01 Invited lecture by Matt Dowle at FNCE3490 Data Science and Business Analytics, Santa Clara University\n\n2016.01 data table discussion, Gaurav Chaturedi & Nicholas Ng, Singapore R User Group\n\n---\n\n## Importe optionnellement `data.table` : `Suggests`\n\nSi vous voulez utiliser `data.table` de manière conditionnelle, c'est-à-dire seulement quand il est installé, vous devriez utiliser `Suggests: data.table` dans votre fichier `DESCRIPTION` au lieu d'utiliser `Imports: data.table`. Par défaut, cette définition ne forcera pas l'installation de `data.table` lors de l'installation de votre package. Cela vous oblige aussi à utiliser conditionnellement `data.table` dans le code de votre package, ce qui doit être fait en utilisant la fonction `?requireNamespace`. L'exemple ci-dessous démontre l'utilisation conditionnelle de la fonction d'écriture de CSV rapide de `?fwrite` du package `data.table`. Si le package `data.table` n'est pas installé, la fonction de base R `?write.table`, beaucoup plus lente, est utilisée à la place.\n\n```r\nmy.write = function (x) {\n if(requireNamespace(\"data.table\", quietly=TRUE)) {\n data.table::fwrite(x, \"data.csv\")\n } else {\n write.table(x, \"data.csv\")\n }\n}\n```\n\nUne version légèrement plus étendue de cette méthode permettrait également de s'assurer que la version installée de `data.table` est suffisamment récente pour que la fonction `fwrite` soit disponible :\n\n```r\nmy.write = function (x) {\n if(requireNamespace(\"data.table\", quietly=TRUE) &&\n utils::packageVersion(\"data.table\") >= \"1.9.8\") {\n data.table::fwrite(x, \"data.csv\")\n } else {\n write.table(x, \"data.csv\")\n }\n}\n```\n\nLorsque vous utilisez un package comme dépendance suggérée, vous ne devez pas l'\"importer\" dans le fichier `NAMESPACE`. Mentionnez-le simplement dans le fichier `DESCRIPTION`. Lorsque vous utilisez les fonctions `data.table` dans le code d'un package (fichiers R/*), vous devez utiliser le préfixe `data.table::` car aucune d'entre elles n'est importée. Lorsque vous utilisez `data.table` dans des packages de tests (par exemple des fichiers tests/testthat/test*), vous devez déclarer `.datatable.aware=TRUE` dans l'un des fichiers R/*.\n\n## `data.table` dans `Imports` mais rien d'importé\n\nCertains utilisateurs ([e.g.](https://github.com/Rdatatable/data.table/issues/2341)) peuvent préférer éviter d'utiliser `importFrom` ou `import` dans leur fichier `NAMESPACE` et utiliser à la place la syntaxe `data.table::` sur tout le code interne (en gardant bien sûr `data.table` sous leurs `Imports:` dans `DESCRIPTION`).\n\nDans ce cas, la fonction non exportée `[.data.table` reviendra à appeler `[.data.frame` comme filet de sécurité puisque `data.table` n'a aucun moyen de savoir que le package parent est conscient qu'il tente de faire des appels en utilisant la syntaxe de l'API de requête de `data.table` (ce qui pourrait conduire à un comportement inattendu car la structure des appels à `[.data.frame` et `[.data.table` diffère fondamentalement, par exemple, ce dernier a beaucoup plus d'arguments).\n\nSi c'est l'approche que vous préférez pour le développement de packages, définissez `.datatable.aware = TRUE` n'importe où dans votre code source R (pas besoin d'exporter). Cela indique à `data.table` que vous, en tant que développeur du package, avez conçu votre code pour qu'il s'appuie intentionnellement sur les fonctionnalités de `data.table`, même si cela n'est pas évident en inspectant votre fichier `NAMESPACE`.\n\n`data.table` détermine à la volée si la fonction appelante est consciente qu'elle puise dans `data.table` avec la fonction interne `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), qui, en plus de vérifier le `?getNamespaceImports` de votre package, vérifie également l'existence de cette variable (entre autres choses).\n\n## Plus d'informations sur les dépendances\n\nPour une documentation plus canonique sur la définition de la dépendance des packages, consultez le manuel officiel : [Writing R Extensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html).\n\n## Importation des routines C de data.table\n\n---\n\n# Seal of Approval\n\nThis is a list of packages in the `data.table` community.\n\nFurther detail about these packages and their relationship to `data.table` can be found at [The Raft blog](https://rdatatable-community.github.io/The-Raft/#category=seal%20of%20approval).\n\nTo add your package to this list, please [submit a Pull Request to The Raft](https://github.com/rdatatable-community/The-Raft/), making sure to follow the templated instructions.\n\n## Extension packages\n\nAdds to the internal functionality of `data.table`.\n\n- [nc](https://github.com/tdhock/nc): Named capture regular expressions for text parsing and data reshaping.\n\n## Application packages\n\nUses `data.table` to accomplish a particular task or analysis.\n\n- [mlr3](https://github.com/mlr-org/mlr3): A versatile machine learning framework built on data.table.\n\n## Bridge packages\n\nTranslates `data.table` syntax to a different syntax, or provides helper functions for transitioning between `data.table` and another object type.\n\n- [tidyfast](https://github.com/TysonStanley/tidyfast): Fast and efficient alternatives to tidyr functions built on `data.table`.\n\n- [dtplyr](https://github.com/tidyverse/dtplyr): A `data.table` backend for `dplyr`.\n\n## Partner packages\n\nNot necessarily directly connected to `data.table`, but deliberately follows the [core philosophies of `data.table`](https://github.com/Rdatatable/data.table/blob/master/GOVERNANCE.md#the-r-package).\n\n- [collapse](https://github.com/SebKrantz/collapse): Advanced and Fast Data Transformation in R.\n\n---\n\nFuture talks\n\nPast talks\n\n2025.06.27: Toby Hocking, Time and memory efficient R programming, French slides for R Ladies Paris online meetup, video.\n\n2025.06.24: What makes R strong - Atelier Global Actuarial Conference, Zurich, Switzerland - by Jan Gorecki, slides.\n\n2025.05.19: Toby Hocking, French slides for data.table tutorial at Recontres R, Mons, Belgium, data.table pour la traitement efficace des grands jeux de données.\n\n2025.05.15: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Bernd Bischl's lab meeting at LMU in Munich, slides.\n\n2025.05.08: Toby Hocking, Using and contributing to the data.table package for efficient big data analysis, for Zurich Applied Statistics seminar, announcement, slides.\n\n2025.03: Toby Hocking, Short talk about data.table for Julie Josse lab in Montpellier, slides\n\n2025.02: Toby Hocking, Madrid R User Group, Video.\n\n2024.12: Toby Hocking, PyData Global, Dec 2024, Video.\n\n2024.11.07: R package dependencies in production - III Congress & XIV R User Conference, Sevilla, Spain - by Jan Gorecki, slides.\n\n2024.10.15: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, \"Women in Statistics and Data Science conference 2024\" Presentation Speed Talk and Poster Presentation\n\n2024.08.06: \"Creating a self-sustaining ecosystem for data.table\" by Ani, JSM 2024 (Portland, Oregon), Slides\n\n2024.08.06: Tyson S. Barrett, \"Efficient Tools for Your Tidy Workflow: A case for incorporating data.table\", JSM 2024 in Portland, OR slides\n\n2024.07.11: Doris Afriyie Amoakohene, Performance Testing and Comparative Benchmarking for data.table, useR! 2024 online presentation video, useR! 2024 presentation in Salzburg, Austria slides\n\n2024.07.09: Tyson S. Barrett, \"The Past, Present, and Future of data.table\", useR! 2024 presentation in Salzburg, Austria slides\n\n2024.05.18: Tyson S. Barrett, \"data.table: New Developments\", R Finance 2024 presentation in Chicago slides\n\n2024.03.28: Toby Dylan Hocking, R Project in Google Summer of Code, virtual talk for Chicago R User Group, slides.\n\n2024.03.05: \"GitHub Actions: Automated performance regression testing on pull requests\" by Ani, NAU SICCS (Flagstaff, AZ), Slides\n\n2024.02.29: David Shilane, R Programming: Introduction to data.table, course at Conference on Statistical Practice (CSP2024), slides and practice exercises\n\n2024.02.08: intro to data.table at SevillaR: High productivity data frame operations with data.table, by Jan Gorecki, slides, video.\n\n2024.01.26: Rolling statistics - Edinburgh R user group meeting, Edinburgh, United Kingdom, by Jan Gorecki, slides\n\n2023.10.18: Using and contributing to the data.table package for efficient big data analysis - LatinR meeting, Montevideo, Uruguay. * Original presentation by Toby Dylan Hocking, google slides, source files. * Spanish translation by Mara Destefanis.\n\n2020.04: Manejo eficiente de grandes volúmenes de datos usando el paquete data.table en R - Nestor Montano, Diapositivas Youtube Playlist Facebook Playlist\n\n2020.04: Data wrangling and cleaning with data.table - Grant McDermott, Big Data in Economics (UOregon)\n\n2020.02.01: Machine Learning and Data Munging in H2O Driverless AI with (python) datatable - Parul Pandey, Hyderabad AI & DL meetup\n\n2020.01.30: List-columns in data.table - Tyson Barrett, rstudio::conf(2020L)\n\n2019.12.26: Efficiency in data processing. data.table basics - Jan Gorecki, R@IISA 2019\n\n2019.10 : data.table for R and Python, Matt Dowle, H2OWorld New York\n\n2019.10 : Why I love data.table, Chris Mainey, Warwick R User Group\n\n2019.09 : Introduction to data.table, Jan Gorecki, whyR? Warsaw\n\n2019.07 : Not So Standard Deviations; 84 - All The Easy Issues, Hilary Parker and Roger Peng\n\n2019.07 : How to use .SD in the data.table package, Sharon Machlis, IDG TECHtalk\n\n2019.07 : Summary of developments in R's data.table package, Arun Srinivasan, useR! Toulouse\n\n---\n\nPara que data.table pueda heredar de `data.frame` sin usar `...`. Si usáramos `...`, no se detectarían los nombres de argumentos no válidos.\n\nEl argumento `drop` nunca se utiliza en `[.data.table`. Es un marcador de posición para paquetes que no son compatibles con data.table cuando usan la sintaxis `[.data.frame` directamente en un data.table.\n\n## ¡Las uniones continuas son geniales y rapidísimas! ¿Fue difícil programarlas?\n\nLa fila que prevalece en o antes de la fila `i` es la última fila que la búsqueda binaria prueba. Por lo tanto, `roll = TRUE` es básicamente un cambio en el código C de búsqueda binaria para devolver esa fila.\n\n## ¿Por qué `DT[i, col := value]` devuelve `DT` completo? Esperaba que no hubiera ningún valor visible (consistente con `<-`), o un mensaje o valor de retorno que indicara cuántas filas se actualizaron. No es evidente que los datos se hayan actualizado por referencia.\n\nEsto ha cambiado en la v1.8.3 para cumplir con sus expectativas. Actualice.\n\nSe devuelve la totalidad de `DT` (ahora de forma invisible) para que la sintaxis compuesta funcione; p. ej., `DT[i, done := TRUE][ , sum(done)]`. El número de filas actualizadas se devuelve cuando `verbose` es `TRUE`, ya sea por consulta o globalmente mediante `options(datatable.verbose = TRUE)`.\n\n## Bien, gracias. ¿Qué tenía de difícil que el resultado de `DT[i, col := valor]` se devolviera de forma invisible?\n\nR activa internamente la visibilidad para `[`. El valor de la columna eval de FunTab (ver [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) para `[` es `0`, lo que significa que se activa `R_Visible` (ver [R-Internals sección 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting)). Por lo tanto, al intentar `invisible()` o configurar `R_Visible` a `0` directamente, `eval` en [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) lo activaba de nuevo.\n\nPara solucionar este problema, la clave fue dejar de intentar detener la ejecución del método de impresión después de un `:=`. En su lugar, dentro de `:=` ahora (a partir de la v1.8.3) configuramos un indicador global que el método de impresión usa para determinar si imprimir o no.\n\n## ¿Por qué a veces tengo que escribir 'DT' dos veces después de usar ':=' para imprimir el resultado en la consola?\n\nEsta es una desventaja desafortunada para que [#869](https://github.com/Rdatatable/data.table/issues/869) funcione. Si se usa un `:=` dentro de una función sin `DT[]` antes del final de la función, la próxima vez que se escriba `DT` en el prompt, no se imprimirá nada. Un `DT` repetido se imprimirá. Para evitar esto: incluya un `DT[]` después del último `:=` en su función. Si eso no es posible (por ejemplo, no es una función que pueda cambiar), se garantiza que `print(DT)` y `DT[]` en el prompt se imprimirán. Como antes, agregar un `[]` adicional al final de la consulta `:=` es un modismo recomendado para actualizar y luego imprimir; por ejemplo, `DT[,foo:=3L][]`.\n\n## He observado que `base::cbind.data.frame` (y `base::rbind.data.frame`) parecen ser modificados por data.table. ¿Cómo es posible? ¿Por qué?\n\n---\n\n# Moved here out from data.table.R on 10 Aug 2017. See data.table.R for history prior to that.\n\n---\n\nLe mécanisme des options dans R est *global*. Cela signifie que si un utilisateur définit une option `data.table` pour son propre usage, ce réglage affecte également le code de tout package qui utilise `data.table`. Pour une option comme `datable.verbose`, c'est exactement le comportement désiré puisque le but est de tracer et d'enregistrer toutes les opérations de `data.table` d'où qu'elles viennent ; activer la verbosité n'affecte pas les résultats. Une autre option unique à R et excellente pour la production est `options(warn=2)` qui transforme tous les avertissements en erreurs. Encore une fois, le but est d'affecter n'importe quel avertissement dans n'importe quel package afin de ne manquer aucun avertissement en production. Il y a 6 options `datable.print.*` et 3 options d'optimisation qui n'affectent pas le résultat des opérations. Cependant, il y a une option `data.table` qui l'affecte et qui est maintenant un problème : `datatable.nomatch`. Cette option change la jointure par défaut d'externe à interne. [A côté de cela, la jointure par défaut est externe parce que outer est plus sûr ; il ne laisse pas tomber les données manquantes silencieusement ; de plus, il est cohérent avec la façon dont la base R fait correspondre les noms et les indices]. Certains utilisateurs préfèrent que la jointure interne soit la valeur par défaut et nous avons prévu cette option pour eux. Cependant, un utilisateur qui met en place cette option peut involontairement changer le comportement des jointures à l'intérieur des packages qui utilisent `data.table`. En conséquence, dans la version 1.12.4 (Oct 2019), un message était affiché lorsque l'option `datable.nomatch` était utilisée, et à partir de la version 1.14.2, elle est maintenant ignorée avec un avertissement. C'était la seule option `datable.table` qui posait ce problème.\n\n## Dépannage\n\nSi vous rencontrez des problèmes lors de la création d'un package qui utilise data.table, veuillez confirmer que le problème est reproductible dans une session R propre en utilisant la console R : `R CMD check nom.package`.\n\nCertains des problèmes les plus courants auxquels les développeurs sont confrontés sont généralement liés à des outils d'aide destinés à automatiser certaines tâches de développement de package, par exemple, l'utilisation de `roxygen` pour générer votre fichier `NAMESPACE` à partir des métadonnées des fichiers de code R. D'autres sont liés aux outils d'aide qui construisent et vérifient les package. D'autres sont liées aux aides qui construisent et vérifient le package. Malheureusement, ces aides ont parfois des effets secondaires inattendus/cachés qui peuvent masquer la source de vos problèmes. Ainsi, assurez-vous de faire une double vérification en utilisant la console R (lancez R sur la ligne de commande) et assurez-vous que l'importation est définie dans les fichiers `DESCRIPTION` et `NAMESPACE` en suivant les [instructions](#DESCRIPTION) [ci-dessus](#NAMESPACE).\n\nSi vous n'êtes pas en mesure de reproduire les problèmes que vous rencontrez en utilisant la simple console R pour construire (\"build\") et vérifier (\"check\"), vous pouvez essayer d'obtenir de l'aide en vous basant sur les problèmes que nous avons rencontrés dans le passé avec `data.table` interagissant avec des outils d'aide : [devtools#192](https://github.com/r-lib/devtools/issues/192) ou [devtools#1472](https://github.com/r-lib/devtools/issues/1472).\n\n## Licence\n\nDepuis la version 1.10.5, `data.table` est sous licence Mozilla Public License (MPL). Les raisons du changement de la GPL peuvent être lues en entier [ici](https://github.com/Rdatatable/data.table/pull/2456) et vous pouvez en savoir plus sur la MPL sur Wikipedia [ici](https://en.wikipedia.org/wiki/Mozilla_Public_License) et [ici](https://en.wikipedia.org/wiki/Comparison_of_free_and_open-source_software_licenses).\n\n## Importe optionnellement `data.table` : `Suggests`\n\n---\n\nSetting \\code{options(datatable.verbose=TRUE)} will display various information about how rolling function processed. It will not print information in real-time but only at the end of the processing.\n}\n\\value{\n For a non \\emph{vectorized} input (\\code{x} is not a list, and \\code{n} specifies a single rolling window) a \\code{vector} is returned, for convenience. Thus, rolling functions can be used conveniently within \\code{data.table} syntax. For a \\emph{vectorized} input a list is returned.\n}\n\\note{\n Be aware that rolling functions operate on the physical order of input. If the intent is to roll values in a vector by a logical window, for example an hour, or a day, then one has to ensure that there are no gaps in the input, or use an adaptive rolling function to handle gaps, for which we provide helper function \\code{\\link{frolladapt}} to generate adaptive window size.\n}\n\\section{\\code{has.nf} argument}{\n \\code{has.nf} can be used to speed up processing in cases when it is known if \\code{x} contains (or not) non-finite values (\\code{NA}, \\code{NaN}, \\code{Inf}, \\code{-Inf}).\n \\itemize{\n \\item Default \\code{has.nf=NA} uses faster implementation that does not support non-finite values, but when non-finite values are detected it will re-run non-finite aware implementation.\n \\item \\code{has.nf=TRUE} uses non-finite aware implementation straightaway.\n \\item \\code{has.nf=FALSE} uses faster implementation that does not support non-finite values. Then depending on the rolling function it will either:\n \\itemize{\n \\item (\\emph{mean, sum, prod, var, sd}) detect non-finite, re-run non-finite aware.\n \\item (\\emph{max, min, median}) does not detect non-finites and may silently produce an incorrect answer.\n }\n }\n In general \\code{has.nf=FALSE && any(!is.finite(x))} should be considered undefined behavior. Therefore \\code{has.nf=FALSE} should be used with care.\n}\n\\section{Implementation}{\n Most of the rolling functions have 4 different implementations. First factor that decides which implementation is used is the \\code{adaptive} argument (either \\code{TRUE} or \\code{FALSE}), see section below for details. Then for each of those two algorithms there are usually two implementations depending on the \\code{algo} argument.\n \\itemize{\n \\item \\code{algo=\"fast\"} uses \\emph{\"online\"}, single pass, algorithm.\n \\itemize{\n \\item \\emph{max} and \\emph{min} rolling function will not do only a single pass but, on average, they will compute \\code{length(x)/n} nested loops. The larger the window, the greater the advantage over the \\emph{exact} algorithm, which computes \\code{length(x)} nested loops. Note that \\emph{exact} uses multiple CPUs so for a small window sizes and many CPUs it may actually be faster than \\emph{fast}. However, in such cases the elapsed timings will likely be far below a single second.\n \\item \\emph{median} will use a novel algorithm described by \\emph{Jukka Suomela} in his paper \\emph{Median Filtering is Equivalent to Sorting (2014)}. See references section for the link. Implementation here is extended to support arbitrary length of input and an even window size. Despite extensive validation of results this function should be considered experimental. When missing values are detected it will fall back to slower \\code{algo=\"exact\"} implementation.\n \\item \\emph{var} and \\emph{sd} will use numerically stable \\emph{Welford}'s online algorithm.\n \\item Not all functions have \\emph{fast} implementation available. As of now, adaptive \\emph{max}, \\emph{min}, \\emph{median}, \\emph{var} and \\emph{sd} do not have \\emph{fast} adaptive implementation, therefore it will automatically fall back to \\emph{exact} adaptive implementation. Similarly, non-adaptive fast implementations of \\emph{median}, \\emph{var} and \\emph{sd} will fall back to \\emph{exact} implementations if they detect any non-finite values in the input. \\code{datatable.verbose} option can be used to check that.\n }\n\n---\n\n### Testing\n\n`data.table` uses a series of unit tests to exhibit code that is expected to work. These are primarily stored in [`inst/tests/tests.Rraw`](https://github.com/Rdatatable/data.table/blob/master/inst/tests/tests.Rraw). They come primarily from two places -- when new features are implemented, the author constructs minimal examples demonstrating the expected common usage of said feature, including expected failures/invalid use cases (e.g., the [initial assay of `fwrite` included 24 tests](https://github.com/Rdatatable/data.table/pull/1613/files#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae)). Second, when kind users such as yourself happen upon some aberrant behavior in their everyday use of `data.table` (typically, some edge case that slipped through the cracks in the coding logic of the original author). We try to be thorough -- for example there were initially [141 tests of `split.data.table`](https://github.com/Rdatatable/data.table/commit/5f7a435fea5622bfbe1d5f1ffa99fa94a6a054ae#diff-e3243f3780ce7d303c3317f73945310bfc37e45d193568246246aca20e3270ae), and that number has since grown!\n\nWhen you file a pull request, you should add some tests to this file with this in mind -- for new features, try to cover possible use cases extensively (we use [Codecov](https://app.codecov.io/gh/Rdatatable/data.table) to make it a bit easier to see how well you've done to minimally cover any new code you've added); for bug fixes, include a minimal version of the problem you've identified and write a test to ensure that your fix indeed works, and thereby guarantee that your fix continues to work as the codebase is further modified in the future. We encourage you to scroll around in `tests.Rraw` a bit to get a feel for the types of examples that are being created, and how bugs are tested/features evaluated.\n\nWhat numbers should be used for new tests? Numbers should be new relative to current master at the time of your PR. If another PR is merged before yours, then there may be a conflict, but that is no problem, as [a Committer will fix the test numbers when merging your PR](https://github.com/Rdatatable/data.table/pull/4731#issuecomment-768858134).\n\n#### Using `test`\n\nSee [`?test`](https://rdatatable.gitlab.io/data.table/reference/test.html).\n\n**References:** If you are not sure how to create a PR, but would like to contribute, these links should help get you started:\n\n1. **[How to Github: Fork, Branch, Track, Squash and Pull request](https://gun.io/blog/how-to-github-fork-branch-and-pull-request/)**.\n1. **[Squashing Github pull requests into a single commit](http://eli.thegreenplace.net/2014/02/19/squashing-github-pull-requests-into-a-single-commit)**.\n1. **[Github help](https://help.github.com/articles/using-pull-requests/)** - you'll need the *fork and pull* model.\n\n#### Performance testing\n\nIf your PR may have an effect on time/memory usage, please consider adding a performance test, either in the same PR, or a follow-up PR. Note that first-time contributors _must_ do so in a follow-up PR, since the tests are only run on PRs from branches created directly in the Rdatatable/data.table repo. See the [Performance testing](https://github.com/Rdatatable/data.table/wiki/Performance-testing) wiki page for details.\n\nMinimal first time PR\n---------------------\n\n```shell\ncd /tmp # or anywhere safe to play\ngit config --global core.autocrlf false # Windows-only preserve \\n in test data\ngit clone https://github.com/Rdatatable/data.table.git\ncd data.table\nR CMD build .\nR CMD check data.table_*.tar.gz\n# ...\n# Status: OK\n```\n\nCongratulations - you've just compiled and tested the very latest version of data.table in development. Everything looks good. Now make your changes. Using an editor of your choice, edit the appropriate `.R`, `.md`, `NEWS` and `tests.Rraw` files. Test your changes:\n\n```shell\nrm data.table_*.tar.gz # clean-up old build(s)\nR CMD build .\nR CMD check data.table_*.tar.gz\n```\n\n---\n\n15. `mult=\"all\"` -vs- `mult=\"first\"|\"last\"` now return consistent types and columns, [#340](https://github.com/Rdatatable/data.table/issues/340). Thanks to Michele Carriero for highlighting.\n\n 16. `duplicated.data.table` and `unique.data.table` gains `fromLast = TRUE/FALSE` argument, similar to base. Default value is FALSE. Closes [#347](https://github.com/Rdatatable/data.table/issues/347).\n\n 17. `anyDuplicated.data.table` is now implemented. Closes [#350](https://github.com/Rdatatable/data.table/issues/350). Thanks to M C (bluemagister) for reporting.\n\n 18. Complex j-expressions of the form `DT[, c(..., lapply(.SD, fun)), by=grp]`are now optimised as long as `.SD` is of the form `lapply(.SD, fun)` or `.SD`, `.SD[1]` or `.SD[1L]`. This resolves [#370](https://github.com/Rdatatable/data.table/issues/370). Thanks to Sam Steingold for reporting.\n This also completes the first two task lists in [#735](https://github.com/Rdatatable/data.table/issues/735).\n ```R\n ## example:\n DT[, c(.I, lapply(.SD, sum), mean(x), lapply(.SD, log)), by=grp]\n ## is optimised to\n DT[, list(.I, x=sum(x), y=sum(y), ..., mean(x), log(x), log(y), ...), by=grp]\n ## and now... these variations are also optimised internally for speed\n DT[, c(..., .SD, lapply(.SD, sum), ...), by=grp]\n DT[, c(..., .SD[1], lapply(.SD, sum), ...), by=grp]\n DT[, .SD, by=grp]\n DT[, c(.SD), by=grp]\n DT[, .SD[1], by=grp] # Note: but not yet DT[, .SD[1,], by=grp]\n DT[, c(.SD[1]), by=grp]\n DT[, head(.SD, 1), by=grp] # Note: but not yet DT[, head(.SD, -1), by=grp]\n # but not yet optimised\n DT[, c(.SD[a], .SD[x>1], lapply(.SD, sum)), by=grp] # where 'a' is, say, a numeric or a data.table, and also for expressions like x>1\n ```\n The underlying message is that `.SD` is being slowly optimised internally wherever possible, for speed, without compromising in the nice readable syntax it provides.\n\n 19. `setDT` gains `keep.rownames = TRUE/FALSE` argument, which works only on `data.frame`s. TRUE retains the data.frame's row names as a new column named `rn`.\n\n 20. The output of `tables()` now includes `NCOL`. Thanks to @dnlbrky for the suggestion.\n\n 21. `DT[, LHS := RHS]` (or its equivalent in `set`) now provides a warning and returns `DT` as it was, instead of an error, when `length(LHS) = 0L`, [#343](https://github.com/Rdatatable/data.table/issues/343). For example:\n ```R\n DT[, grep(\"^b\", names(DT)) := NULL] # where no columns start with b\n # warns now and returns DT instead of error\n ```\n\n 22. GForce now is also optimised for j-expression with `.N`. Closes [#334](https://github.com/Rdatatable/data.table/issues/334) and part of [#523](https://github.com/Rdatatable/data.table/issues/523).\n ```R\n DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.2 - doesn't know to use GForce - will be (relatively) slower\n DT[, list(.N, mean(y), sum(y)), by=x] # 1.9.3+ - will use GForce.\n ```\n\n 23. `setDF` is now implemented. It accepts a data.table and converts it to data.frame by reference, [#338](https://github.com/Rdatatable/data.table/issues/338). Thanks to canneff for the discussion on data.table mailing list.\n\n 24. `.I` gets named as `I` (instead of `.I`) wherever possible, similar to `.N`, [#344](https://github.com/Rdatatable/data.table/issues/344).\n\n 25. `setkey` on `.SD` is now an error, rather than warnings for each group about rebuilding the key. The new error is similar to when attempting to use `:=` in a `.SD` subquery: `\".SD is locked. Using set*() functions on .SD is reserved for possible future use; a tortuously flexible way to modify the original data by group.\"` Thanks to Ron Hylton for highlighting the issue on datatable-help.\n\n 26. Looping calls to `unique(DT)` such as in `DT[,unique(.SD),by=group]` is now faster by avoiding internal overhead of calling `[.data.table`. Thanks again to Ron Hylton for highlighting on datatable-help. His example is reduced from 28 sec to 9 sec, with identical results.\n\n---\n\nEn este caso, la función no exportada `[.data.table` volverá a llamar a `[.data.frame` como medida de protección, ya que `data.table` no tiene forma de saber que el paquete padre es consciente de que está intentando realizar llamadas contra la sintaxis de la API de consulta de `data.table` (lo que podría generar un comportamiento inesperado ya que la estructura de las llamadas a `[.data.frame` y `[.data.table` difieren fundamentalmente, por ejemplo, este último tiene muchos más argumentos).\n\nSi este es su enfoque preferido para el desarrollo de paquetes, defina `.datatable.aware = TRUE` en cualquier parte de su código fuente de R (no es necesario exportar). Esto indica a `data.table` que usted, como desarrollador de paquetes, ha diseñado su código para que utilice intencionalmente su funcionalidad, aunque no sea evidente al inspeccionar su archivo `NAMESPACE`.\n\n`data.table` determina sobre la marcha si la función que llama es consciente de que está accediendo a `data.table` con la función interna `cedta` (**C**alling **E**nvironment is **D**ata **T**able **A**ware), que, además de verificar `?getNamespaceImports` para su paquete, también verifica la existencia de esta variable (entre otras cosas).\n\n## Más información sobre las dependencias\n\nPara obtener documentación más canónica sobre la definición de dependencia de paquetes, consulte el manual oficial: [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html).\n\n## Importación de rutinas data.table C\n\nAlgunas de las rutinas C utilizadas internamente ahora se exportan a nivel C, por lo que se pueden usar en paquetes R directamente desde su código C. Consulte [`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) para obtener detalles y la sección [Escritura de extensiones R](https://cran.r-project.org/doc/manuals/r-release/R-exts.html) *Enlace a rutinas nativas en otros paquetes* para su uso.\n\n## Importación desde aplicaciones que no son r {#non-r-api}\n\nAlgunas pequeñas partes del código C de `data.table` se aislaron de la API de RC y ahora pueden usarse desde aplicaciones que no sean de R mediante enlaces a archivos .so o .dll. Más adelante se proporcionarán detalles más concretos al respecto; por ahora, puede estudiar el código C aislado de la API de RC en [src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c) y [src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c).\n\n## Cómo convertir su dependencia Depends en data.table a Imports\n\nPara convertir una dependencia `Depends` de `data.table` en una dependencia `Imports` en su paquete, siga estos pasos:\n\n### Paso 0. Asegúrese de que su paquete pase la verificación R CMD inicialmente\n\n### Paso 1. Actualice el archivo DESCRIPTION para colocar data.table en Imports, no en Depends\n\n**Antes:**\n\n```dcf\nDepends:\n R (>= 3.5.0),\n data.table\nImports:\n```\n\n**Después:**\n\n```dcf\nDepends:\n R (>= 3.5.0)\nImports:\n data.table\n```\n\n### Paso 2.1: Ejecutar `R CMD check`\n\nEjecute `R CMD check` para identificar importaciones o símbolos faltantes. Este paso ayuda a:\n\n- Detecta automáticamente cualquier función o símbolo de `data.table` que no se importe explícitamente.\n- Marca los símbolos especiales faltantes como `.N`, `.SD` y `:=`.\n- Proporciona retroalimentación inmediata sobre lo que se debe agregar al archivo NAMESPACE.\n\nNota: No todos estos usos son detectados por `R CMD check`. En particular, `R CMD check` omite algunos símbolos/funciones en fórmulas y no detecta expresiones analizadas como `parse(text = \"data.table(a = 1)\")`. Los paquetes necesitarán una buena cobertura de pruebas para detectar estos casos extremos.\n\n### Paso 2.2: Modificar el archivo NAMESPACE\n\nSegún los resultados de `R CMD check`, asegúrese de que se importen todas las funciones utilizadas, los símbolos especiales, los genéricos S3 y las clases S4 de `data.table`.\n\n---\n\nThis is an internal list for me to get an idea of the type of Q that come up often, and how many Q could potentially benefit from non-equi joins.. (+ aggregate/update feature of data.table). These are the Q I've come across so far.\n\n---\n\n## Où sont les archives de datatable-help ?\n\nLa [page d'accueil](https://github.com/Rdatatable/data.table/wiki) contient des liens vers les archives en plusieurs formats.\n\n## Je préférerais ne pas publier sur la page \"Questions\" (Issues). Puis-je envoyer un email à une ou deux personnes ?\n\nBien sûr, mais il est plus probable que vous obteniez une réponse plus rapide sur la page Issues ou sur Stack Overflow. De plus, le fait de poser des questions publiquement à ces endroits aide à construire la base de connaissances générale.\n\n## J'ai créé un package qui utilise data.table. Comment puis-je m'assurer que mon package est compatible avec data.table pour que l'héritage de `data.frame` fonctionne ?\n\nVoir [cette réponse](https://stackoverflow.com/a/10529888/403310).\n\n```{r, echo=FALSE}\nsetDTthreads(.old.th)\n```\n\n---\n\n```{r}\nDT = data.table(\n ID = c(\"b\",\"b\",\"b\",\"a\",\"a\",\"c\"),\n a = 1:6,\n b = 7:12,\n c = 13:18\n)\nDT\nclass(DT$ID)\n```\n\nVous pouvez aussi convertir des objets existants en une `data.table` en utilisant `setDT()` (pour les structures `data.frame` et `list`) ou `as.data.table()` (pour les autres structures). Pour les autres détails concernant les différences (ce qui est hors du champ de cette vignette), voir `?setDT` et `?as.data.table`.\n\n#### Notez que :\n\n* Les numéros de ligne sont imprimés avec un `:` afin de séparer visuellement le numéro de ligne de la première colonne.\n\n* Lorsque le nombre de lignes à imprimer dépasse l'option globale `datatable.print.nrows` (défaut = `r getOption(\"datatable.print.nrows\")`), il n'imprime automatiquement que les 5 premières et les 5 dernières lignes (comme on peut le voir dans la section [Data](#data)). Pour un grand `data.frame`, vous avez pu vous retrouver à attendre que des tables plus grandes s'impriment et se mettent en page, parfois sans fin. Cette restriction permet d'y remédier, et vous pouvez demander le nombre par défaut de la façon suivante : \n\n ```{.r}\n getOption(\"datatable.print.nrows\")\n ```\n\n* `data.table` ne définit ni n'utilise jamais de *nom de ligne*. Nous verrons pourquoi dans la [`vignette(\"datatable-keys-fast-subset\", package=\"data.table\")`](datatable-keys-fast-subset.html).\n\n### b) Forme générale - dans quel sens la 'data.table' est-elle *étendue* ? {#enhanced-1b}\n\nPar rapport à un `data.frame`, vous pouvez faire *beaucoup plus de choses* qu'extraire des lignes et sélectionner des colonnes dans la structure d'une `data.table`, par exemple, avec `[ ... ]` (Notez bien : nous pourrions aussi faire référence à écrire quelque chose dans `DT[...]` comme \"interroger `DT`\", par analogie ou similairement à SQL). Pour le comprendre il faut d'abord que nous regardions la *forme générale* de la syntaxe `data.table`, comme indiqué ci-dessous :\n\n```r\nDT[i, j, by]\n\n## R: i j by\n## SQL: where | order by select | update group by\n```\n\nLes utilisateurs ayant des connaissances SQL feront peut être directement le lien avec cette syntaxe.\n\n#### La manière de le lire (à haute voix) est :\n\nUtiliser `DT`, extraire ou trier les lignes en utilisant `i`, puis calculer `j`, grouper avec `by`.\n\nCommençons par voir 'i' et 'j' d'abord - en indiçant les lignes et en travaillant sur les colonnes.\n\n### c) Regrouper les lignes en 'i' {#subset-i-1c}\n\n#### -- Obtenir tous les vols qui ont \"JFK\" comme aéroport de départ pendant le mois de juin.\n\n```{r}\nans <- flights[origin == \"JFK\" & month == 6L]\nhead(ans)\n```\n\n* Dans le cadre d'un `data.table`, on peut se référer aux colonnes *comme s'il s'agissait de variables*, un peu comme dans SQL ou Stata. Par conséquent, nous nous référons simplement à `origin` et `month` comme s'il s'agissait de variables. Nous n'avons pas besoin d'ajouter le préfixe `vol$` à chaque fois. Néanmoins, l'utilisation de `flights$origin` et `flights$month` fonctionnerait parfaitement.\n\n* Les *indices de ligne* qui satisfont la condition `origin == \"JFK\" & month == 6L` sont calculés, et puisqu'il n'y a rien d'autre à faire, toutes les colonnes de `flights` aux lignes correspondant à ces *indices de ligne* sont simplement renvoyées sous forme d’un `data.table`.\n\n* Une virgule après la condition dans `i` n'est pas nécessaire. Mais `flights[origin == \"JFK\" & month == 6L, ]` fonctionnerait parfaitement. Avec un `data.frame`, cependant, la virgule est indispensable.\n\n#### -- Récupérer les deux premières lignes de `flights`. {#subset-rows-integer}\n\n```{r}\nans <- flights[1:2]\nans\n```\n\n* Dans ce cas, il n'y a pas de condition. Les indices des lignes sont déjà fournis dans `i`. Nous retournons donc un `data.table` avec toutes les colonnes de `flights` aux lignes pour ces *index de ligne*.\n\n#### -- Trier `flights` d'abord sur la colonne `origin` dans l'ordre *ascending*, puis par `dest` dans l'ordre *descendant* :\n\n---\n\n### NOTES\n\n 1. Clearer explanation of what `duplicated()` does (borrowed from base). Thanks to @matthieugomez for pointing out. Closes [#872](https://github.com/Rdatatable/data.table/issues/872).\n\n 2. `?setnames` has been updated now that `names<-` and `colnames<-` shallow (rather than deep) copy from R >= 3.1.0, [#853](https://github.com/Rdatatable/data.table/issues/853).\n\n 3. [FAQ 1.6](https://github.com/Rdatatable/data.table/wiki/vignettes/datatable-faq.pdf) has been embellished, [#517](https://github.com/Rdatatable/data.table/issues/517). Thanks to a discussion with Vivi and Josh O'Brien.\n\n 4. `data.table` redefines `melt` generic and *suggests* `reshape2` instead of *import*. As a result we don't have to load `reshape2` package to use `melt.data.table` anymore. The reason for this change is that `data.table` requires R >=2.14, whereas `reshape2` R v3.0.0+. Reshape2's melt methods can be used without any issues by loading the package normally.\n\n 5. `DT[, j, ]` at times made an additional (unnecessary) copy. This is now fixed. This fix also avoids allocating `.I` when `j` doesn't use it. As a result `:=` and other subset operations should be faster (and use less memory). Thanks to @szilard for the nice report. Closes [#921](https://github.com/Rdatatable/data.table/issues/921).\n\n 6. Because `reshape2` requires R >3.0.0, and `data.table` works with R >= 2.14.1, we can not import `reshape2` anymore. Therefore we define a `melt` generic and `melt.data.table` method for data.tables and redirect to `reshape2`'s `melt` for other objects. This is to ensure that existing code works fine.\n\n 7. `dcast` is also a generic now in data.table. So we can use `dcast(...)` directly, and don't have to spell it out as `dcast.data.table(...)` like before. The `dcast` generic in data.table redirects to `reshape2::dcast` if the input object is not a data.table. But for that you have to load `reshape2` before loading `data.table`. If not, reshape2's `dcast` overwrites data.table's `dcast` generic, in which case you will need the `::` operator - ex: `data.table::dcast(...)`.\n\n NB: Ideal situation would be for `dcast` to be a generic in reshape2 as well, but it is not. We have issued a [pull request](https://github.com/hadley/reshape/pull/62) to make `dcast` in reshape2 a generic, but that has not yet been accepted.\n\n 8. Clarified the use of `bit64::integer4` in `merge.data.table()` and `setNumericRounding()`. Closes [#1093](https://github.com/Rdatatable/data.table/issues/1093). Thanks to @sfischme for the report.\n\n 9. Removed an unnecessary (and silly) `giveNames` argument from `setDT()`. Not sure why I added this in the first place!\n\n 10. `options(datatable.prettyprint.char=5L)` restricts the number of characters to be printed for character columns. For example:\n ```\n options(datatable.prettyprint.char = 5L)\n DT = data.table(x=1:2, y=c(\"abcdefghij\", \"klmnopqrstuv\"))\n DT\n # x y\n # 1: 1 abcde...\n # 2: 2 klmno...\n ````\n\n 11. `rolltolast` argument in `[.data.table` is now defunct. It was deprecated in 1.9.4.\n\n 12. `data.table`'s dependency has been moved forward from R 2.14.0 to R 2.14.1, now nearly 4 years old (Dec 2011). As usual before release to CRAN we ensure data.table passes the test suite on the stated dependency and keep this as old as possible for as long as possible. As requested by users in managed environments. For this reason we still don't use `paste0()` internally, since that was added to R 2.15.0.\n\n 13. Warning about `datatable.old.bywithoutby` option (for grouping on join without providing `by`) being deprecated in the next release is in place now. Thanks to @jangorecki for the PR.\n\n 14. Fixed `allow.cartesian` documentation to `nrow(x)+nrow(i)` instead of `max(nrow(x), nrow(i))`. Closes [#1123](https://github.com/Rdatatable/data.table/issues/1123).\n\n## data.table v1.9.4 (on CRAN 2 Oct 2014)\n\n### NEW FEATURES\n\n---\n\nPackage: data.table\nVersion: 1.18.99\nTitle: Extension of `data.frame`\nDepends: R (>= 3.5.0)\nImports: methods\nSuggests: bit64 (>= 4.0.0), R.utils, xts, zoo (>= 1.8-1), yaml, litedown, codetools\nEnhances: knitr, xfun\nDescription: Fast aggregation of large data (e.g. 100GB in RAM), fast ordered joins, fast add/modify/delete of columns by group using no copies at all, list columns, friendly and fast character-separated-value read/write. Offers a natural and flexible syntax, for faster development.\nLicense: MPL-2.0 | file LICENSE\nURL: https://r-datatable.com, https://Rdatatable.gitlab.io/data.table, https://github.com/Rdatatable/data.table\nBugReports: https://github.com/Rdatatable/data.table/issues\nVignetteBuilder: litedown\nEncoding: UTF-8\nByteCompile: TRUE\nAuthors@R: c(\n person(\"Tyson\",\"Barrett\", role=c(\"aut\",\"cre\"), email=\"t.barrett88@gmail.com\", comment = c(ORCID=\"0000-0002-2137-1391\")),\n person(\"Matt\",\"Dowle\", role=\"aut\", email=\"mattjdowle@gmail.com\"),\n person(\"Arun\",\"Srinivasan\", role=\"aut\", email=\"asrini@pm.me\"),\n person(\"Jan\",\"Gorecki\", role=\"aut\", email=\"j.gorecki@wit.edu.pl\"),\n person(\"Michael\",\"Chirico\", role=\"aut\", email=\"michaelchirico4@gmail.com\", comment = c(ORCID=\"0000-0003-0787-087X\")),\n person(\"Toby\",\"Hocking\", role=\"aut\", email=\"toby.hocking@r-project.org\", comment = c(ORCID=\"0000-0002-3146-0865\")),\n person(\"Benjamin\",\"Schwendinger\",role=\"aut\", comment = c(ORCID=\"0000-0003-3315-8114\")),\n person(\"Ivan\", \"Krylov\", role=\"aut\", email=\"ikrylov@disroot.org\", comment = c(ORCID=\"0000-0002-0172-3812\")),\n person(\"Pasha\",\"Stetsenko\", role=\"ctb\"),\n person(\"Tom\",\"Short\", role=\"ctb\"),\n person(\"Steve\",\"Lianoglou\", role=\"ctb\"),\n person(\"Eduard\",\"Antonyan\", role=\"ctb\"),\n person(\"Markus\",\"Bonsch\", role=\"ctb\"),\n person(\"Hugh\",\"Parsonage\", role=\"ctb\"),\n person(\"Scott\",\"Ritchie\", role=\"ctb\"),\n person(\"Kun\",\"Ren\", role=\"ctb\"),\n person(\"Xianying\",\"Tan\", role=\"ctb\"),\n person(\"Rick\",\"Saporta\", role=\"ctb\"),\n person(\"Otto\",\"Seiskari\", role=\"ctb\"),\n person(\"Xianghui\",\"Dong\", role=\"ctb\"),\n person(\"Michel\",\"Lang\", role=\"ctb\"),\n person(\"Watal\",\"Iwasaki\", role=\"ctb\"),\n person(\"Seth\",\"Wenchel\", role=\"ctb\"),\n person(\"Karl\",\"Broman\", role=\"ctb\"),\n person(\"Tobias\",\"Schmidt\", role=\"ctb\"),\n person(\"David\",\"Arenburg\", role=\"ctb\"),\n person(\"Ethan\",\"Smith\", role=\"ctb\"),\n person(\"Francois\",\"Cocquemas\", role=\"ctb\"),\n person(\"Matthieu\",\"Gomez\", role=\"ctb\"),\n person(\"Philippe\",\"Chataignon\", role=\"ctb\"),\n person(\"Nello\",\"Blaser\", role=\"ctb\"),\n person(\"Dmitry\",\"Selivanov\", role=\"ctb\"),\n person(\"Andrey\",\"Riabushenko\", role=\"ctb\"),\n person(\"Cheng\",\"Lee\", role=\"ctb\"),\n person(\"Declan\",\"Groves\", role=\"ctb\"),\n person(\"Daniel\",\"Possenriede\", role=\"ctb\"),\n person(\"Felipe\",\"Parages\", role=\"ctb\"),\n person(\"Denes\",\"Toth\", role=\"ctb\"),\n person(\"Mus\",\"Yaramaz-David\", role=\"ctb\"),\n person(\"Ayappan\",\"Perumal\", role=\"ctb\"),\n person(\"James\",\"Sams\", role=\"ctb\"),\n person(\"Martin\",\"Morgan\", role=\"ctb\"),\n person(\"Michael\",\"Quinn\", role=\"ctb\"),\n person(given=\"@javrucebo\", role=\"ctb\", comment=\"GitHub user\"),\n person(\"Marc\",\"Halperin\", role=\"ctb\"),\n person(\"Roy\",\"Storey\", role=\"ctb\"),\n person(\"Manish\",\"Saraswat\", role=\"ctb\"),\n person(\"Morgan\",\"Jacob\", role=\"ctb\"),\n person(\"Michael\",\"Schubmehl\", role=\"ctb\"),\n person(\"Davis\",\"Vaughan\", role=\"ctb\"),\n person(\"Leonardo\",\"Silvestri\", role=\"ctb\"),\n person(\"Jim\",\"Hester\", role=\"ctb\"),\n person(\"Anthony\",\"Damico\", role=\"ctb\"),\n person(\"Sebastian\",\"Freundt\", role=\"ctb\"),\n person(\"David\",\"Simons\", role=\"ctb\"),\n person(\"Elliott\",\"Sales de Andrade\", role=\"ctb\"),\n\n---\n\n## Why `data.table`?\n\n* concise syntax: fast to type, fast to read\n* fast speed\n* memory efficient\n* careful API lifecycle management\n* community\n* feature rich\n\n## Features\n\n* fast and friendly delimited **file reader**: **[`?fread`](https://rdatatable.gitlab.io/data.table/reference/fread.html)**, see also [convenience features for _small_ data](https://github.com/Rdatatable/data.table/wiki/Convenience-features-of-fread)\n* fast and feature rich delimited **file writer**: **[`?fwrite`](https://rdatatable.gitlab.io/data.table/reference/fwrite.html)**\n* low-level **parallelism**: many common operations are internally parallelized to use multiple CPU threads\n* fast and scalable aggregations; e.g. 100GB in RAM (see [benchmarks](https://duckdblabs.github.io/db-benchmark/) on up to **two billion rows**)\n* fast and feature rich joins: **ordered joins** (e.g. rolling forwards, backwards, nearest and limited staleness), **[overlapping range joins](https://github.com/Rdatatable/data.table/wiki/talks/EARL2014_OverlapRangeJoin_Arun.pdf)** (similar to `IRanges::findOverlaps`), **[non-equi joins](https://github.com/Rdatatable/data.table/wiki/talks/ArunSrinivasanUseR2016.pdf)** (i.e. joins using operators `>, >=, <, <=`), **aggregate on join** (`by=.EACHI`), **update on join**\n* fast add/update/delete columns **by reference** by group using no copies at all\n* fast and feature rich **reshaping** data: **[`?dcast`](https://rdatatable.gitlab.io/data.table/reference/dcast.data.table.html)** (_pivot/wider/spread_) and **[`?melt`](https://rdatatable.gitlab.io/data.table/reference/melt.data.table.html)** (_unpivot/longer/gather_)\n* **any R function from any R package** can be used in queries not just the subset of functions made available by a database backend, also columns of type `list` are supported\n* has **[no dependencies](https://en.wikipedia.org/wiki/Dependency_hell)** at all other than base R itself, for simpler production/maintenance\n* the R dependency is **as old as possible for as long as possible**, currently R 3.5.0 (2018), and we continuously test against that version\n\n## Installation\n\n```r\ninstall.packages(\"data.table\")\n\n# latest development version (only if newer available)\ndata.table::update_dev_pkg()\n\n# latest development version (force install)\ninstall.packages(\"data.table\", repos=\"https://rdatatable.gitlab.io/data.table\")\n```\n\nSee [the Installation wiki](https://github.com/Rdatatable/data.table/wiki/Installation) for more details.\n\n## Usage\n\nUse `data.table` subset `[` operator the same way you would use `data.frame` one, but...\n\n* no need to prefix each column with `DT$` (like `subset()` and `with()` but built-in)\n* any R expression using any package is allowed in `j` argument, not just list of columns\n* extra argument `by` to compute `j` expression by group\n\n```r\nlibrary(data.table)\nDT = as.data.table(iris)\n\n# FROM[WHERE, SELECT, GROUP BY]\n# DT [i, j, by]\n\nDT[Petal.Width > 1.0, mean(Petal.Length), by = Species]\n# Species V1\n#1: versicolor 4.362791\n#2: virginica 5.552000\n```\n\n### Getting started\n\n* [Introduction to data.table](https://cran.r-project.org/package=data.table/vignettes/datatable-intro.html) vignette\n* [Getting started](https://github.com/Rdatatable/data.table/wiki/Getting-started) wiki page\n* [Examples](https://rdatatable.gitlab.io/data.table/reference/data.table.html#examples) produced by `example(data.table)`\n\n### Cheatsheets\n\n\n\n## Community\n\n---\n\n# Governance for the R data.table project\n\n# Purpose and scope\n\n## This document\n\nThe purpose of this document is to define how people related to the project work together, so that the project can expand to handle a larger and more diverse group of contributors.\n\n## The R package\n\nThe purpose of the project is to maintain the R data.table package, which is guided by the following principles:\n\n* Time & memory efficiency\n* Concise syntax (minimal redundancy in code)\n* No external Imports/LinkingTo/Depends dependencies (external meaning those not maintained by the project)\n* Few (if any) Suggests/Enhances dependencies\n* Stable code base (strong preference for user-friendly back-compatibility with data.table itself and with old versions of R)\n* Comprehensive and accessible documentation and run-time signals (errors, warnings)\n\nTo prioritize developer time, we define what is in and out of current scope. Feature requests in issues and pull requests that are out of current scope should be closed immediately, because they are not the current priority. If someone wants to contribute code that is currently out of scope, they first have to make a pull request that changes the scope as defined below.\n\nThe current scope of package functionality includes:\n* data manipulation and analysis \n * reshaping/pivoting\n * aggregation/summarizing (via `[,, by=...]` and _grouping sets_)\n * filtering rows\n * all sorts of joins\n * adding/updating/deleting columns\n * set operations (union/rbind, intersection, difference)\n* high-performance common functions (`frank`, `fcase`, `fifelse`, `transpose`, `chmatch`, `fsort`, `forder`, `uniqueN`, ...)\n* common convenience functions (`%like%`, `%notin%`, `timetaken`, `substitute2`, ...)\n* ordered data functions (`rleid`, `shift`, `fcoalesce`, _locf_/_nocb_ `nafill`, rolling functions)\n* date and time related classes and functions (`IDate`, `ITime`)\n* technical functions (`address`, `tables`, `update_dev_pkg`)\n* Reading/writing of data from/to flat (plain text) files like CSV\n\nFunctionality that is out of current scope:\n* Plotting/graphics (like ggplot2)\n* Manipulating out-of-memory data, e.g. data stored on disk or remote SQL DB, (as opposed e.g. to sqldf / dbplyr)\n* Machine learning (like mlr3)\n* Reading/writing of data from/to binary files like parquet\n\n# Roles \n\n## Contributor\n\n* Definition: a user who has written/commented at least one issue, worked to label/triage issues, written a blog post, given a talk, etc. \n* How this role is recognized: there is no central list of Contributors / no formal recognition for Contributors.\n\n## Project Member\n\n* Definition: some one who has submitted at least one PR with substantial contributions, that has been merged into master. PRs improving documentation are welcome, and substantial contributions to the docs should count toward Project Membership, but minor contributions such as spelling fixes do not count toward Project Membership.\n* How to obtain this role: anybody can become a Project Member by submitting a PR with substantial contributions, then having it reviewed and merged into master. Contributors who have written issues should be encouraged to submit their first PR to become a Project Member. Contributors can look at https://github.com/Rdatatable/data.table/labels/beginner-task for easy issues to work on.\n* How this role is recognized: Project Members are credited via role=\"ctb\" in DESCRIPTION (so they appear in Author list on CRAN), and they are added to https://github.com/orgs/Rdatatable/teams/project-members so they can create new branches in the Rdatatable/data.table GitHub repo. They also appear on https://github.com/Rdatatable/data.table/graphs/contributors (Contributions to master, excluding merge commits).\n\n## Reviewer\n\n---\n\nAinsi, data.table peut hériter de `data.frame` sans utiliser `...`. Si nous utilisions `...`, les noms d'arguments invalides ne seraient pas détectés.\n\nL'argument `drop` n'est jamais utilisé par `[.data.table`. C'est un substitut pour les packages non compatibles avec data.table lorsqu'ils utilisent la syntaxe `[.data.frame` directement sur un data.table.\n\n## Les jonctions par roulement sont cool et très rapides ! C'était difficile à programmer ?\n\nLa ligne dominante sur ou avant la ligne `i` est la ligne finale que la recherche binaire teste de toute façon. Donc `roll = TRUE` est essentiellement un interrupteur dans le code C de la recherche binaire pour retourner cette ligne.\n\n## Pourquoi `DT[i, col := valeur]` retourne-t-il la totalité de `DT` ? Je m'attendais à ce qu'il n'y ait pas de valeur visible (ce qui est cohérent avec `<-`), ou à ce qu'il y ait un message ou une valeur de retour contenant le nombre de lignes mises à jour. Il n'est pas évident que les données aient été mises à jour par référence.\n\nCeci a été modifié dans la version 1.8.3 pour répondre à vos attentes. Veuillez mettre à jour.\n\nL'ensemble de `DT` est retourné (maintenant de manière invisible) pour que la syntaxe composée puisse fonctionner ; *e.g.*, `DT[i, done := TRUE][ , sum(done)]`. Le nombre de lignes mises à jour est retourné quand `verbose` est `TRUE`, soit sur une base par requête, soit globalement en utilisant `options(datatable.verbose = TRUE)`.\n\n## D'accord, merci. Qu'y a-t-il de si difficile dans le fait que le résultat de `DT[i, col := value]` soit renvoyé de façon invisible ?\n\nR force en interne la visibilité pour `[`. La valeur de la colonne eval de FunTab (voir [src/main/names.c](https://github.com/wch/r-source/blob/trunk/src/main/names.c)) pour `[` est `0` ce qui signifie \"force `R_Visible` on\" (voir [R-Internals section 1.6](https://cran.r-project.org/doc/manuals/r-release/R-ints.html#Autoprinting) ). Par conséquent, lorsque nous avons essayé `invisible()` ou de mettre `R_Visible` à `0` directement nous-mêmes, `eval` dans [src/main/eval.c](https://github.com/wch/r-source/blob/trunk/src/main/eval.c) l'a forcé à nouveau.\n\nPour résoudre ce problème, la clé était de ne plus essayer d'arrêter l'exécution de la méthode print après un `:=`. Au lieu de cela, à l'intérieur de `:=` nous mettons maintenant (à partir de la version 1.8.3) un drapeau global que la méthode print utilise pour savoir si elle doit imprimer ou non.\n\n## Pourquoi dois-je taper `DT` parfois deux fois après avoir utilisé `:=` pour imprimer le résultat dans la console ?\n\nC'est un inconvénient malheureux pour faire fonctionner [#869](https://github.com/Rdatatable/data.table/issues/869). Si un `:=` est utilisé à l'intérieur d'une fonction sans `DT[]` avant la fin de la fonction, alors la prochaine fois que `DT` est tapé à l'invite, rien ne sera affiché. Un `DT` répété sera affiché. Pour éviter cela : incluez un `DT[]` après le dernier `:=` dans votre fonction. Si ce n'est pas possible (par exemple, ce n'est pas une fonction que vous pouvez changer), alors `print(DT)` et `DT[]` à l'invite sont garantis de s’afficher. Comme précédemment, l'ajout d'un `[]` supplémentaire à la fin de la requête `:=` est un idiome recommandé pour mettre à jour et ensuite imprimer ; e.g.> `DT[,foo:=3L][]`.\n\n## J'ai remarqué que `base::cbind.data.frame` (et `base::rbind.data.frame`) semble être modifié par data.table. Comment cela est-il possible ? Pourquoi ?\n\n---\n\n#include \"data.table.h\"\n\n---\n\n#include \"data.table.h\"\n\n---\n\n3. `DT[col > val, head(.SD, 1), by = ...]` - объединяет `i` с `j` и\n `by`.\n\n#### Также не забывайте:\n\nЕсли `j` возвращает `list`, каждый элемент этого списка станет столбцом в\nрезультирующей `data.table`.\n\nВ [следующем руководстве (`vignette(\"datatable-reference-semantics\",\npackage=\"data.table\")`)](../datatable-reference-semantics.html) мы\nрассмотрим, как *добавлять/обновлять/удалять* столбцы *по ссылке* и как\nкомбинировать эти операции с `i` и `by`.\n\n***\n\n```{r, echo=FALSE}\nsetDTthreads(.old.th)\n```\n\n---\n\n## OK, je commence à comprendre ce qu'est data.table, mais pourquoi n'avez-vous pas simplement amélioré `data.frame` dans R ? Pourquoi faut-il que ce soit un nouveau package ?\n\nComme [souligné ci-dessus] (#j-num), `j` dans `[.data.table` est fondamentalement différent de `j` dans `[.data.frame`. Même si quelque chose d'aussi simple que `DF[ , 1]` était modifié dans la base R pour retourner un data.frame plutôt qu'un vecteur, cela casserait le code existant dans des milliers de package CRAN et dans le code utilisateur. Dès que nous avons pris la décision de créer une nouvelle classe héritant de data.frame, nous avons eu l'opportunité de changer certaines choses et nous l'avons fait. Nous voulons que data.table soit légèrement différent et qu'il fonctionne de cette façon pour que la syntaxe plus compliquée fonctionne. Il existe également d'autres différences (voir [ci-dessous](#PetitesDifférences) ).\n\nDe plus, data.table *hérite* de `data.frame`. C'est aussi un `data.frame`. Un data.table peut être passé à n'importe quel package qui n'accepte que `data.frame` et ce package peut utiliser la syntaxe `[.data.frame` sur le data.table. Voir [cette réponse] (https://stackoverflow.com/a/10529888/403310) pour savoir comment procéder.\n\nNous avons également proposé des améliorations à R chaque fois que cela était possible. L'une d'entre elles a été acceptée comme nouvelle fonctionnalité dans R 2.12.0 :\n\n> `unique()` et `match()` sont maintenant plus rapides sur les vecteurs de caractères où tous les éléments sont dans le cache global CHARSXP et ont un encodage non marqué (ASCII). Merci à Matt Dowle pour avoir suggéré des améliorations dans la façon dont le code de hachage est généré dans unique.c.\n\nUne deuxième proposition était d'utiliser `memcpy` dans duplicate.c, qui est beaucoup plus rapide qu'une boucle for en C. Cela améliorerait la *manière* dont R copie les données en interne (sur certaines mesures, de 13 fois). Le fil de discussion sur r-devel est [ici] (https://stat.ethz.ch/pipermail/r-devel/2010-April/057249.html).\n\nUne troisième proposition plus significative qui a été acceptée est que R utilise maintenant le code de tri par base (radix sort) de data.table à partir de R 3.3.0 :\n\n> L'algorithme de tri par base (radix sort) et l'implémentation de data.table (forder) remplace l'ancien tri par base (comptage) et ajoute une nouvelle méthode pour order(). Proposé par Matt Dowle et Arun Srinivasan, le nouvel algorithme supporte les vecteurs de logiques, d’entiers (même avec de grandes valeurs), de réels et de caractères. Il est plus performant que toutes les autres méthodes, mais il y a quelques mises en garde (voir ?sort).\n\nC'était un grand événement pour nous et nous l'avons fêté jusqu'à ce que les vaches rentrent à la maison. (Pas vraiment.)\n\n## Pourquoi les valeurs par défaut sont-elles telles qu'elles sont ? Pourquoi le système fonctionne-t-il comme il le fait ?\n\nLa réponse est simple : l'auteur principal l'a conçu à l'origine pour son propre usage. C'est ce qu'il voulait. Il trouve que c'est une façon plus naturelle et plus rapide d'écrire du code, qui s'exécute également plus rapidement.\n\n## N'est-ce pas déjà fait par `with()` et `subset()` dans `base` ?\n\nCertaines des caractéristiques discutées jusqu'à présent sont, oui. Le package s'appuie sur la fonctionnalité de base. Il fait le même genre de choses, mais avec moins de code et s'exécute beaucoup plus rapidement s'il est utilisé correctement.\n\n## Pourquoi `X[Y]` retourne-t-il aussi toutes les colonnes de `Y` ? Ne devrait-elle pas retourner un sous-ensemble de `X` ?\n\n---\n\nEl caso de los símbolos especiales de `data.table` (p. ej., `.SD` y `.N`) y el operador de asignación (`:=`) es ligeramente diferente (consulte `?.N` para obtener más información, incluyendo una lista completa de dichos símbolos). Debe importar cualquiera de estos valores que utilice del espacio de nombres de `data.table` para evitar problemas derivados del improbable escenario de que cambiemos el valor exportado de estos en el futuro. Por ejemplo, si desea usar `.N`, `.I` y `:=`, un `NAMESPACE` mínimo tendría:\n\n```r\nimportFrom(data.table, .N, .I, ':=')\n```\n\nMucho más simple es simplemente usar `import(data.table)`, lo que permitirá el uso en el código de su paquete de cualquier objeto exportado desde `data.table`.\n\nSi no le importa tener `id` y `grp` registrados como variables globales en el espacio de nombres de su paquete, puede usar `?globalVariables`. Tenga en cuenta que estas notas no afectan el código ni su funcionalidad; si no va a publicar su paquete, puede simplemente ignorarlas.\n\n## Se debe tener cuidado al proporcionar y utilizar `options`\n\nUna práctica común en los paquetes de R es proporcionar opciones de personalización definidas por `options(name=val)` y obtenidas mediante `getOption(\"name\", default)`. Los argumentos de función suelen especificar una llamada a `getOption()` para que el usuario conozca (a través de `?fun` o `args(fun)`) el nombre de la opción que controla el valor predeterminado para ese parámetro; por ejemplo, `fun(..., verbose=getOption(\"datatable.verbose\", FALSE))`. Todas las opciones de `data.table` comienzan con `datatable.` para evitar conflictos con las opciones de otros paquetes. El usuario simplemente llama a `options(datatable.verbose=TRUE)` para activar la verbosidad. Esto afecta a todas las llamadas a la función data.table, a menos que `verbose=FALSE` se especifique explícitamente; por ejemplo, `fun(..., verbose=FALSE)`.\n\nEl mecanismo de opciones en R es *global*. Esto significa que si un usuario establece una opción `data.table` para su propio uso, esa configuración también afecta al código dentro de cualquier paquete que también esté usando `data.table`. Para una opción como `datatable.verbose`, este es exactamente el comportamiento deseado ya que el deseo es rastrear y registrar todas las operaciones de `data.table` desde donde sea que se originen; activar la verbosidad no afecta los resultados. Otra opción única de R y excelente para producción es `options(warn=2)` de R que convierte todas las advertencias en errores. Nuevamente, el deseo es afectar cualquier advertencia en cualquier paquete para no perder ninguna advertencia en producción. Hay 6 opciones `datatable.print.*` y 3 opciones de optimización que no afectan el resultado de las operaciones. Sin embargo, hay una opción `data.table` que sí afecta y ahora es una preocupación: `datatable.nomatch`. Esta opción cambia la unión predeterminada de externa a interna. [Aparte, la unión predeterminada es externa porque externa es más segura; no elimina los datos faltantes silenciosamente; Además, es coherente con el método R básico para la coincidencia por nombres e índices. Algunos usuarios prefieren que la unión interna sea la opción predeterminada, y les proporcionamos esta opción. Sin embargo, si un usuario configura esta opción, puede cambiar involuntariamente el comportamiento de las uniones dentro de paquetes que usan `data.table`. Por consiguiente, en la versión 1.12.4 (octubre de 2019) se mostraba un mensaje al usar la opción `datatable.nomatch`, y a partir de la versión 1.14.2, se ignora con una advertencia. Era la única opción de `data.table` con este problema.\n\n## Solución de problemas\n\nSi enfrenta algún problema al crear un paquete que usa data.table, confirme que el problema se pueda reproducir en una sesión R limpia usando la consola R: `R CMD check package.name`.\n\n---\n\n12. Clarified `with=FALSE` as suggested in [#513](https://github.com/Rdatatable/data.table/issues/513).\n\n 13. Clarified `.I` in `?data.table`. Closes [#510](https://github.com/Rdatatable/data.table/issues/510). Thanks to Gabor for reporting.\n\n 14. Moved `?copy` to its own help page, and documented that `dt_names <- copy(names(DT))` is necessary for `dt_names` to be not modified by reference as a result of updating `DT` by reference (e.g. adding a new column by reference). Closes [#512](https://github.com/Rdatatable/data.table/issues/512). Thanks to Zach for [this SO question](https://stackoverflow.com/q/15913417/559784) and user1971988 for [this SO question](https://stackoverflow.com/q/18662715/559784).\n\n 15. `address(x)` doesn't increment `NAM()` value when `x` is a vector. Using the object as argument to a non-primitive function is sufficient to increment its reference. Closes #824. Thanks to @tarakc02 for the [question on twitter](https://twitter.com/tarakc02/status/513796515026837504) and hint from Hadley.\n\n---\n\n## data.table v1.9.2 (on CRAN 27 Feb 2014)\n\n### NEW FEATURES\n\n 1. Fast methods of `reshape2`'s `melt` and `dcast` have been implemented for `data.table`, **FR #2627**. Most settings are identical to `reshape2`, see `?melt.data.table.`\n > `melt`: 10 million rows and 5 columns, 61.3 seconds reduced to 1.2 seconds.\n > `dcast`: 1 million rows and 4 columns, 192 seconds reduced to 3.6 seconds.\n\n * `melt.data.table` is also capable of melting on columns of type `list`.\n * `melt.data.table` gains `variable.factor` and `value.factor` which by default are TRUE and FALSE respectively for compatibility with `reshape2`. This allows for directly controlling the output type of \"variable\" and \"value\" columns (as factors or not).\n * `melt.data.table`'s `na.rm = TRUE` parameter is optimised to remove NAs directly during melt and therefore avoids the overhead of subsetting using `!is.na` afterwards on the molten data.\n * except for `margins` argument from `reshape2:::dcast`, all features of dcast are intact. `dcast.data.table` can also accept `value.var` columns of type list.\n\n > Reminder of Cologne (Dec 2013) presentation **slide 32** : [\"Why not submit a dcast pull request to reshape2?\"](https://github.com/Rdatatable/data.table/wiki/talks/CologneR_2013.pdf).\n\n 2. Joins scale better as the number of rows increases. The binary merge used to start on row 1 of i; it now starts on the middle row of i. Many thanks to Mike Crowe for the suggestion. This has been done within column so scales much better as the number of join columns increase, too.\n\n > Reminder: bmerge allows the rolling join feature: forwards, backwards, limited and nearest.\n\n 3. Sorting (`setkey` and ad-hoc `by=`) is faster and scales better on randomly ordered data and now also adapts to almost sorted data. The remaining comparison sorts have been removed. We use a combination of counting sort and forwards radix (MSD) for all types including double, character and integers with range>100,000; forwards not backwards through columns. This was inspired by [Terdiman](https://codercorner.com/RadixSortRevisited.htm) and [Herf's](http://stereopsis.com/radix.html) (LSD) radix approach for floating point :\n\n 4. `unique` and `duplicated` methods for `data.table` are significantly faster especially for type numeric (i.e. double), and type integer where range > 100,000 or contains negatives.\n\n 5. `NA`, `NaN`, `+Inf` and `-Inf` are now considered distinct values, may be in keys, can be joined to and can be grouped. `data.table` defines: `NA` < `NaN` < `-Inf`. Thanks to Martin Liberts for the suggestions, #4684, #4815 and #4883.\n\n---\n\n# Test case created directly using the atime code below (not adapted from any other benchmark), based on the PR, Removes unnecessary data.table call from as.data.table.array https://github.com/Rdatatable/data.table/pull/7010 \n \"as.data.table.array improved in #7010\" = atime::atime_test(\n setup = {\n dims = c(N, 1, 1)\n arr = array(seq_len(prod(dims)), dim=dims)\n },\n expr = data.table:::as.data.table.array(arr, na.rm=FALSE),\n Slow = \"73d79edf8ff8c55163e90631072192301056e336\", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/8397dc3c993b61a07a81c786ca68c22bc589befc)\n Fast = \"8397dc3c993b61a07a81c786ca68c22bc589befc\"), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7019/commits) that removes inefficiency\n\n \"isoweek improved in #7144\" = atime::atime_test(\n setup = {\n set.seed(349)\n x = sample(Sys.Date() - 0:5000, N, replace=TRUE)\n },\n expr = data.table::isoweek(x),\n Slow = \"548410d23dd74b625e8ea9aeb1a5d2e9dddd2927\", # Parent of the first commit in the PR (https://github.com/Rdatatable/data.table/commit/548410d23dd74b625e8ea9aeb1a5d2e9dddd2927)\n Fast = \"c0b32a60466bed0e63420ec105bc75c34590865e\"), # Commit in the PR (https://github.com/Rdatatable/data.table/pull/7144/commits) that uses a much faster implementation\n\n # Regression introduced in #7404 (grouped by factor).\n \"DT[by] max regression fixed in #7480\" = atime::atime_test(\n N = as.integer(10^seq(3, 5, by=0.5)),\n setup = {\n dt = data.table(\n id = as.factor(rep(seq_len(N), each = 100L)),\n V1 = 1L\n )\n },\n expr = data.table:::`[.data.table`(dt, , base::max(V1, na.rm = TRUE), by = id),\n Before = \"476de7e3\",\n Regression = \"6f49bf1\",\n Fixed = \"b6ad1a4\",\n seconds.limit = 1),\n tests=extra.test.list)\n# nolint end: undesirable_operator_linter.\n\n---\n\nRunning comparative performance benchmarks to portray the relative efficiency of operations, i.e., in contrast to other packages that achieve similar functionality as data.table.\n\nWriting open-source material like blog posts to document such (with code to run the benchmarks provisioned therein), as they would tend to be a great resource for the community. Examples: df-atime-figures, df-partial-match\n\nDesigning test scenarios to measure performance, such as handling large datasets, performing complex queries, having concurrent operations, etc.\n\nStaying informed with the latest developments in R programming and performance testing methodologies to bring such updates to data.table.\n\n---\n\nThese articles either focus on data.table (bold) or mention/use it (perhaps only briefly and you may need to search the article for \"data.table\"), ordered by date. If you know of an article that may be of interest to others, please add it here (). You can also search all articles from the R blogosphere since c. 2009 on http://www.r-bloggers.com/. There is no filter applied: if the article exists and mentions data.table, positively or negatively, it is included on this page. Please watch out for benchmarks measured in milliseconds.** Comparisons on such small scales often do not hold when scaled up to larger data because, for example, they over-represent call overhead and/or the dataset is so small it fits in CPU cache. A test repetition count (e.g. ntimes=) of 5 or more is often an indication that the test data size is too small. Please check that setkey() has been used and its time reported separately. Tutorials, slides and videos are over on the Videos & Slides page.\n\n(**) all pages on this wiki have no write restrictions. You are encouraged to change content in this wiki yourself as you see fit. Changes will go live immediately with no oversight by any project member. If you spot any abuse, please check the edit history to see who made the edit and please inform us.\n\n---\n\n```{r}\nDT = data.table(\n ID = c(\"b\",\"b\",\"b\",\"a\",\"a\",\"c\"),\n a = 1:6,\n b = 7:12,\n c = 13:18\n)\nDT\nclass(DT$ID)\n```\n\nTambién puede convertir objetos existentes a una tabla `data.table` mediante `setDT()` (para estructuras `data.frame` y `list`) o `as.data.table()` (para otras estructuras). Para más detalles sobre la diferencia (que excede el alcance de este artículo), consulte `?setDT` y `?as.data.table`.\n\n#### Tenga en cuenta que:\n\n* Los números de fila se imprimen con un `:` para separar visualmente el número de fila de la primera columna.\n\n* Cuando el número de filas a imprimir excede la opción global `datatable.print.nrows` (predeterminado = `r getOption(\"datatable.print.nrows\")`), se imprimen automáticamente solo las 5 primeras y las 5 últimas filas (como se puede ver en la sección [Data](#data)). Con un `data.frame` grande, es posible que haya tenido que esperar mientras tablas más grandes se imprimen y paginan, a veces sin parar. Esta restricción ayuda con esto, y puede consultar el número predeterminado de la siguiente manera:\n\n ```{.r}\n getOption(\"datatable.print.nrows\")\n ```\n\n* `data.table` nunca establece ni usa *nombres de fila*. Veremos por qué en la viñeta [`vignette(\"datatable-keys-fast-subset\", package=\"data.table\")`](datatable-keys-fast-subset.html).\n\n### b) Forma general: ¿de qué manera se *mejora* una `data.table`? {#enhanced-1b}\n\nA diferencia de un `data.frame`, se puede hacer *mucho más* que simplemente filtrar filas y seleccionar columnas dentro del marco de un `data.table`, es decir, dentro de `[ ... ]` (Nota: también podríamos referirnos a escribir dentro de `DT[...]` como \"consultar `DT`\", como analogía o en relación con SQL). Para comprenderlo, primero debemos analizar la *forma general* de la sintaxis de `data.table`, como se muestra a continuación:\n\n```r\nDT[i, j, by]\n\n## R: i j by\n## SQL: where | order by select | update group by\n```\n\nLos usuarios con conocimientos de SQL probablemente se sentirán inmediatamente identificados con esta sintaxis.\n\n#### La forma de leerlo (en voz alta) es:\n\nTomar `DT`, filtrar/reordenar filas usando `i`, luego calcular `j`, agrupado por `by`.\n\nComencemos mirando primero `i` y `j`: filtrando filas y operando en columnas.\n\n### c) Filtrar filas en `i` {#subset-i-1c}\n\n#### -- Obtenga todos los vuelos con \"JFK\" como aeropuerto de origen en el mes de junio.\n\n```{r}\nans <- flights[origin == \"JFK\" & month == 6L]\nhead(ans)\n```\n\n* Dentro de una tabla `data.table`, se puede hacer referencia a las columnas *como si fueran variables*, de forma similar a SQL o Stata. Por lo tanto, simplemente nos referimos a `origin` y `month` como si fueran variables. No es necesario añadir el prefijo `flights$` cada vez. Sin embargo, usar `flights$origin` y `flights$month` funcionaría perfectamente.\n\n* Se calculan los *índices de fila* que satisfacen la condición `origin == \"JFK\" & month == 6L` y, como no queda nada más por hacer, todas las columnas de `flights` en las filas correspondientes a esos *índices de fila* simplemente se devuelven como una `data.table`.\n\n* No se requiere una coma después de la condición en `i`. Pero `flights[origin == \"JFK\" & month == 6L, ]` funcionaría perfectamente. Sin embargo, en un `data.frame`, la coma es necesaria.\n\n#### -- Obtener las dos primeras filas de `vuelos`. {#subset-rows-integer}\n\n```{r}\nans <- flights[1:2]\nans\n```\n\n* En este caso, no hay ninguna condición. Los índices de fila ya se proporcionan en `i`. Por lo tanto, devolvemos una `data.table` con todas las columnas de `flights` en las filas para esos *índices de fila*.\n\n#### -- Ordena `vuelos` primero por la columna `origen` en orden *ascendente*, y luego por `dest` en orden *descendente*:\n\nPodemos utilizar la función R `order()` para lograr esto.\n\n```{r}\nans <- flights[order(origin, -dest)]\nhead(ans)\n```\n\n#### `order()` está optimizado internamente\n\n---\n\n9. `print.data.table()` (all via master issue [#1523](https://github.com/Rdatatable/data.table/issues/1523)):\n\n * gains `print.keys` argument, `FALSE` by default, which displays the keys and/or indices (secondary keys) of a `data.table`. Thanks @MichaelChirico for the PR, Yike Lu for the suggestion and Arun for honing that idea to its present form.\n\n * gains `col.names` argument, `\"auto\"` by default, which toggles which registers of column names to include in printed output. `\"top\"` forces `data.frame`-like behavior where column names are only ever included at the top of the output, as opposed to the default behavior which appends the column names below the output as well for longer (>20 rows) tables. `\"none\"` shuts down column name printing altogether. Thanks @MichaelChirico for the PR, Oleg Bondar for the suggestion, and Arun for guiding commentary.\n\n * list columns would print the first 6 items in each cell followed by a comma if there are more than 6 in that cell. Now it ends \",...\" to make it clearer, part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). Thanks to @franknarf1 for drawing attention to an issue raised on Stack Overflow by @TMOTTM [here](https://stackoverflow.com/q/47679701).\n\n10. `setkeyv` accelerated if key already exists [#2331](https://github.com/Rdatatable/data.table/issues/2331). Thanks to @MarkusBonsch for the PR.\n\n11. Keys and indexes are now partially retained up to the key column assigned to with ':=' [#2372](https://github.com/Rdatatable/data.table/issues/2372). They used to be dropped completely if any one of the columns was affected by `:=`. Tanks to @MarkusBonsch for the PR.\n\n12. Faster `as.IDate` and `as.ITime` methods for `POSIXct` and `numeric`, [#1392](https://github.com/Rdatatable/data.table/issues/1392). Thanks to Jan Gorecki for the PR.\n\n13. `unique(DT)` now returns `DT` early when there are no duplicates to save RAM, [#2013](https://github.com/Rdatatable/data.table/issues/2013). Thanks to Michael Chirico for the PR, and thanks to @mgahan for pointing out a reversion in `na.omit.data.table` before release, [#2660](https://github.com/Rdatatable/data.table/issues/2660#issuecomment-371027948).\n\n14. `uniqueN()` is now faster on logical vectors. Thanks to Hugh Parsonage for [PR#2648](https://github.com/Rdatatable/data.table/pull/2648).\n\n ```R\n N = 1e9\n # was now\n x = c(TRUE,FALSE,NA,rep(TRUE,N)) #\n uniqueN(x) == 3 # 5.4s 0.00s\n x = c(TRUE,rep(FALSE,N), NA) #\n uniqueN(x,na.rm=TRUE) == 2 # 5.4s 0.00s\n x = c(rep(TRUE,N),FALSE,NA) #\n uniqueN(x) == 3 # 6.7s 0.38s\n ```\n\n15. Subsetting optimization with keys and indices is now possible for compound queries like `DT[a==1 & b==2]`, [#2472](https://github.com/Rdatatable/data.table/issues/2472).\nThanks to @MichaelChirico for reporting and to @MarkusBonsch for the implementation.\n\n16. `melt.data.table` now offers friendlier functionality for providing `value.name` for `list` input to `measure.vars`, [#1547](https://github.com/Rdatatable/data.table/issues/1547). Thanks @MichaelChirico and @franknarf1 for the suggestion and use cases, @jangorecki and @mrdwab for implementation feedback, and @MichaelChirico for ultimate implementation.\n\n17. `update.dev.pkg` is new function to update package from development repository, it will download package sources only when newer commit is available in repository. `data.table::update.dev.pkg()` defaults updates `data.table`, but any package can be used.\n\n18. Item 1 in NEWS for [v1.10.2](https://github.com/Rdatatable/data.table/blob/master/NEWS.md#changes-in-v1102--on-cran-31-jan-2017) on CRAN in Jan 2017 included :\n\n---\n\n# one and two+ row cases of data.table, as.data.table and cbind involving list columns, given\n# the change to tests 1613.571-3 in PR#3471 in v1.12.4\n# in v1.12.2 and before :\n# data.table( data.table(1:2), list(c(\"a\",\"b\"),\"a\") )\n# V1 V2 NA\n# \n# 1: 1 a a\n# 2: 2 b a\n# i.e. passing a data.table() to data.table() changed the meaning of list() which was inconsistent,\n# and an NA column name was introduced too (a bug in itself)\n# from v1.12.4 :\n# V1 V2\n# \n# 1: 1 a,b\n# 2: 2 a\n# i.e. now easier to add the list column as intended, and it's consistent with\n# basic (i.e. not cbind-like) usage of data.table()\n# # changed in v1.12.4 ?\nans = data.table(V1=1, V2=2) # --------------------\ntest(2058.01, data.table( data.table(1), 2), ans) # no\ntest(2058.02, as.data.table(list(data.table(1), 2)), ans) # no\ntest(2058.03, cbind(data.table(1), 2), ans) # no\nans = data.table(V1=1, V2=list(2)) # 'basic' usage; i.e. not cbind-like\ntest(2058.04, sapply(ans, class), c(V1=\"numeric\", V2=\"list\")) # no\ntest(2058.05, data.table( data.table(1), list(2) ), ans) # yes\ntest(2058.06, as.data.table(list(data.table(1), list(2))), ans) # yes\ntest(2058.07, cbind(data.table(1), list(2)), ans) # yes\nans = data.table(V1=1:2, V2=list(c(\"a\",\"b\"),\"a\"))\ntest(2058.08, sapply(ans, class), c(V1=\"integer\", V2=\"list\")) # no\ntest(2058.09, data.table( data.table(1:2), list(c(\"a\",\"b\"),\"a\") ), ans) # yes\ntest(2058.10, as.data.table(list(data.table(1:2), list(c(\"a\",\"b\"),\"a\"))), ans) # yes\ntest(2058.11, cbind(data.table(1:2), list(c(\"a\",\"b\"),\"a\")), ans) # yes\ntest(2058.12, cbind(first=data.table(A=1:3), second=data.table(A=4, B=5:7)),\n data.table(first.A=1:3, second.A=4, second.B=5:7)) # no\ntest(2058.13, cbind(data.table(A=1:3), second=data.table(A=4, B=5:7)),\n data.table(A=1:3, second.A=4, second.B=5:7)) # no\ntest(2058.14, cbind(data.table(A=1,B=2),3), data.table(A=1,B=2,V2=3)) # no\nL = list(1:3, 4:6)\ntest(2058.15, as.data.table(L), data.table(V1=1:3, V2=4:6)) # no\n# retain all-blank list names as batchtools relies on in reg$defs[1,job.pars], #3581\nnames(L) = c(\"\",\"\")\ntest(2058.16, as.data.table(L), setnames(data.table(1:3, 4:6),c(\"\",\"\"))) # no\n# retain existing duplicate and blank names of a plain-list, just as 1.12.2 did\nL = list(1:3, 4:6, 7:9, 10:12)\nnames(L) = c(\"\",\"foo\",\"\",\"foo\")\ntest(2058.17, as.data.table(L),\n setnames(data.table(1:3, 4:6, 7:9, 10:12),c(\"\",\"foo\",\"\",\"foo\"))) # no\nL = list(1:3, NULL, 4:6)\ntest(2058.18, length(L), 3L)\ntest(2058.19, as.data.table(L), data.table(V1=1:3, V2=4:6)) # V2 not V3 # no\nDT = data.table(a=1:3, b=c(4,5,6))\ntest(2058.20, DT[,b:=list(NULL)], data.table(a=1:3)) # no\n\n---\n\n## fichier `NAMESPACE` {#NAMESPACE}\n\nLa prochaine chose à faire est de définir le contenu de `data.table` que votre package utilise. Cela doit être fait dans le fichier `NAMESPACE`. Le plus souvent, les auteurs de package voudront utiliser `import(data.table)` qui importera toutes les fonctions exportées (c'est-à-dire listées dans le fichier `NAMESPACE` de `data.table`) de `data.table`.\n\nVous pouvez aussi ne vouloir utiliser qu'un sous-ensemble des fonctions de `data.table` ; par exemple, certains packages peuvent simplement utiliser les fonctions d'écriture et lecture CSV haute performance de `data.table`, pour lesquelles vous pouvez ajouter `importFrom(data.table, fread, fwrite)` dans votre fichier `NAMESPACE`. Il est également possible d'importer toutes les fonctions d'un package *en excluant* certaines d'entre elles en utilisant `import(data.table, except=c(fread, fwrite))`.\n\nAssurez-vous de lire également la note sur l'évaluation non standard dans `data.table` dans [la section sur les \"globales non définies\"](#globals)\n\n## Utilisation\n\nA titre d'exemple, nous allons définir deux fonctions dans le package `a.pkg` qui utilise `data.table`. Une fonction, `gen`, générera un simple `data.table` ; une autre, `aggr`, en fera une simple agrégation.\n\n```r\ngen = function (n = 100L) {\n dt = as.data.table(list(id = seq_len(n)))\n dt[, grp := ((id - 1) %% 26) + 1\n ][, grp := letters[grp]\n ][]\n}\naggr = function (x) {\n stopifnot(\n is.data.table(x),\n \"grp\" %in% names(x)\n )\n x[, .N, by = grp]\n}\n```\n\n## Tests\n\nAssurez-vous d'inclure des tests dans votre package. Avant chaque version majeure de `data.table`, nous vérifions les dépendances inverses. Cela signifie que si un changement dans `data.table` casse votre code, nous serons capables de repérer les changements et de vous en informer avant de publier la nouvelle version. Cela suppose bien sûr que vous publiiez votre package sur CRAN ou Bioconductor. Le test le plus basique peut être un script R en clair dans le répertoire `tests/test.R` de votre package :\n\n```r\nlibrary(a.pkg)\ndt = gen()\nstopifnot(nrow(dt) == 100)\ndt2 = aggr(dt)\nstopifnot(nrow(dt2) < 100)\n```\n\nLorsque vous testez votre package, vous pouvez utiliser `R CMD check --no-stop-on-test-error`, qui continuera après une erreur et exécutera tous vos tests (au lieu de s'arrêter à la première ligne du script qui a échoué).\n\n## Tester en utilisant `testthat`\n\nIl est très courant d'utiliser le package `testthat` pour effectuer des tests. Tester un package qui importe `data.table` n'est pas différent de tester d'autres packages. Un exemple de script de test `tests/testthat/test-pkg.R` :\n\n```r\ncontext(\"pkg tests\")\n\ntest_that(\"generate dt\", { expect_true(nrow(gen()) == 100) })\ntest_that(\"aggregate dt\", { expect_true(nrow(aggr(gen())) < 100) })\n```\n\nSi `data.table` est dans Suggests (mais pas dans Imports) alors vous devez déclarer `.datatable.aware=TRUE` dans un des fichiers R/* pour éviter les erreurs \"object not found\" lors des tests via `testthat::test_package` ou `testthat::test_check`.\n\n## Traitement des \"fonctions ou variables globales indéfinies\" (\"undefined global functions or variables\") {#globals}\n\nl'utilisation par `data.table` de l'évaluation différée de R (en particulier sur le côté gauche de `:=`) n'est pas bien reconnue par `R CMD check`. Il en résulte des `NOTE`s comme la suivante lors de la vérification du package :\n\n```\n* checking R code for possible problems ... NOTE\naggr: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'id'\nUndefined global functions or variables:\ngrp id\n```\n\n---\n\nThank you for contributing to data.table!\n\nPlease be sure to read our [CONTRIBUTING guide](CONTRIBUTING.md). In particular, \"Contributors are requested not to use code assistants if they are not able to evaluate license of the code provided by an assistant, and to provide proper citation.\"\n\n\n\n---\n\n3. `print` method for `data.table` gains `trunc.cols` argument (and corresponding option `datatable.print.trunc.cols`, default `FALSE`), [#1497](https://github.com/Rdatatable/data.table/issues/1497), part of [#1523](https://github.com/Rdatatable/data.table/issues/1523). This prints only as many columns as fit in the console without wrapping to new lines (e.g., the first 5 of 80 columns) and a message that states the count and names of the variables not shown. When `class=TRUE` the message also contains the classes of the variables. `data.table` has always automatically truncated _rows_ of a table for efficiency (e.g. printing 10 rows instead of 10 million); in the future, we may do the same for _columns_ (e.g., 10 columns instead of 20,000) by changing the default for this argument. Thanks to @nverno for the initial suggestion and to @TysonStanley for the PR.\n\n4. `setnames(DT, new=new_names)` (i.e. explicitly named `new=` argument) now works as expected rather than an error message requesting that `old=` be supplied too, [#4041](https://github.com/Rdatatable/data.table/issues/4041). Thanks @Kodiologist for the suggestion.\n\n5. `nafill` and `setnafill` gain `nan` argument to say whether `NaN` should be considered the same as `NA` for filling purposes, [#4020](https://github.com/Rdatatable/data.table/issues/4020). Prior versions had an implicit value of `nan=NaN`; the default is now `nan=NA`, i.e., `NaN` is treated as if it's missing. Thanks @AnonymousBoba for the suggestion. Also, while `nafill` still respects `getOption('datatable.verbose')`, the `verbose` argument has been removed.\n\n6. New function `fcase(...,default)` implemented in C by Morgan Jacob, [#3823](https://github.com/Rdatatable/data.table/issues/3823), is inspired by SQL `CASE WHEN` which is a common tool in SQL for e.g. building labels or cutting age groups based on conditions. `fcase` is comparable to R function `dplyr::case_when` however it evaluates its arguments in a lazy way (i.e. only when needed) as shown below. Please see `?fcase` for more details.\n\n ```R\n # Lazy evaluation\n x = 1:10\n data.table::fcase(\n\t x < 5L, 1L,\n\t x >= 5L, 3L,\n\t x == 5L, stop(\"provided value is an unexpected one!\")\n )\n # [1] 1 1 1 1 3 3 3 3 3 3\n\n dplyr::case_when(\n\t x < 5L ~ 1L,\n\t x >= 5L ~ 3L,\n\t x == 5L ~ stop(\"provided value is an unexpected one!\")\n )\n # Error in eval_tidy(pair$rhs, env = default_env) :\n # provided value is an unexpected one!\n\n # Benchmark\n x = sample(1:100, 3e7, replace = TRUE) # 114 MB\n microbenchmark::microbenchmark(\n dplyr::case_when(\n x < 10L ~ 0L,\n x < 20L ~ 10L,\n x < 30L ~ 20L,\n x < 40L ~ 30L,\n x < 50L ~ 40L,\n x < 60L ~ 50L,\n x > 60L ~ 60L\n ),\n data.table::fcase(\n x < 10L, 0L,\n x < 20L, 10L,\n x < 30L, 20L,\n x < 40L, 30L,\n x < 50L, 40L,\n x < 60L, 50L,\n x > 60L, 60L\n ),\n times = 5L,\n unit = \"s\")\n # Unit: seconds\n # expr min lq mean median uq max neval\n # dplyr::case_when 11.57 11.71 12.22 11.82 12.00 14.02 5\n # data.table::fcase 1.49 1.55 1.67 1.71 1.73 1.86 5\n ```\n\n7. `.SDcols=is.numeric` now works; i.e., `SDcols=` accepts a function which is used to select the columns of `.SD`, [#3950](https://github.com/Rdatatable/data.table/issues/3950). Any function (even _ad hoc_) that returns scalar `TRUE`/`FALSE` for each column will do; e.g., `.SDcols=!is.character` will return _non_-character columns (_a la_ `Negate()`). Note that `.SDcols=patterns(...)` can still be used for filtering based on the column names.\n\n---\n\n* Integer-based date and time-of-day classes have been\n introduced. This allows dates and times to be used as keys\n more easily. See as.IDate, as.ITime, and IDateTime.\n Conversions to and from POSIXct, Date, and chron are\n supported.\n\n * [<-.data.table and $<-.data.table were revised to check for\n changes to the key-ed columns. [<-.data.table also now allows\n data.table-style indexing for i. Both of these changes may\n introduce incompatibilities for existing code.\n\n * Logical columns are now allowed in keys and in 'by', as are expressions\n that evaluate to logical. Thanks to David Winsemius for highlighting.\n\n\n### BUG FIXES\n\n * DT[,5] now returns 5 as FAQ 1.1 says, for consistency\n with DT[,c(5)] and DT[,5+0]. DT[,\"region\"] now returns\n \"region\" as FAQ 1.2 says. Thanks to Harish V for reporting.\n\n * When a quote()-ed expression q is passed to 'by' using\n by=eval(q), the group column names now come from the list\n in the expression rather than the name 'q' (bug #974) and,\n multiple items work (bug #975). Thanks to Harish V for\n reporting.\n\n * quote()-ed i and j expressions receive similar fixes, bugs\n #977 and #1058. Thanks to Harish V and Branson Owen for\n reporting.\n\n * Multiple errors (grammar, format and spelling) in intro.Rnw\n and faqs.Rnw corrected by Dennis Murphy. Thank you.\n\n * Memory is now reallocated in rare cases when the up front\n allocate for the result of grouping is insufficient. Bug\n #952 raised by Georg V, and also reported by Harish. Thank\n you.\n\n * A function call foo(arg=sum(b)) now finds b in DT when foo\n contains DT[,eval(substitute(arg)),by=a], fixing bug #1026.\n Thanks to Harish V for reporting.\n\n * If DT contains column 'a' then DT[J(unique(a))] now finds\n 'a', fixing bug #1005. Thanks to Branson Owen for reporting.\n\n * 'by' on no data (for example when 'i' returns no rows) now\n works, fixing bug #709.\n\n * 'by without by' now heeds nomatch=NA, fixing bug #1015.\n Thanks to Harish V for reporting.\n\n * DT[NA] now returns 1 row of NA rather than the whole table\n via standard NA logical recycling. A single NA logical is\n a special case and is now replaced by NA_integer_. Thanks\n to Branson Owen for highlighting the issue.\n\n * NROW removed from data.table, since the is.data.frame() in\n base::NROW now returns TRUE due to inheritance. Fixes bug\n #1039 reported by Bradley Buchsbaum. Thank you.\n\n * setkey() now coerces character to factor and double to\n integer (provided they are all.equal), fixing bug #953.\n Thanks to Steve Lianoglou for reporting.\n\n * 'by' now accepts lists from the calling scope without the\n work around of wrapping with as.list() or {}, fixing bug\n #1060. Thanks to Johann Hibschman for reporting.\n\n\n### NOTES\n\n * The package uses the 'default' option of base::getOption,\n and is therefore dependent on R 2.10.0. Updated DESCRIPTION\n file accordingly. Thanks to Christian Hudon for reporting.\n\n\n## data.table v1.4.1\n\n\n### NEW FEATURES\n\n * Vignettes tidied up.\n\n\n### BUG FIXES\n\n * Out of order levels in key columns are now sorted by\n setkey. Thanks to Steve Lianoglou for reporting.\n\n\n## data.table v1.4\n\n\n### NEW FEATURES\n\n * 'by' faster. Memory is allocated first for the result, then\n populated directly by the result of j for each group. Can be 10\n or more times faster than tapply() and aggregate(), see\n timings vignette.\n\n * j should now be a list(), not DT(), of expressions. Use of\n j=DT(...) is caught internally and replaced with j=list(...).\n\n---\n\n7. Added some clarification about the usage of `on` to `?data.table`, [#2383](https://github.com/Rdatatable/data.table/issues/2383). Thanks to @peterlittlejohn for volunteering his confusion and @MichaelChirico for brushing things up.\n\n8. Clarified that \"data.table always sorts in `C-locale`\" means that upper-case letters are sorted before lower-case letters by ordering in data.table (e.g. `setorder`, `setkey`, `DT[order(...)]`). Thanks to @hughparsonage for the pull request editing the documentation. Note this makes no difference in most cases of data; e.g. ids where only uppercase or lowercase letters are used (`\"AB123\"<\"AC234\"` is always true, regardless), or country names and words which are consistently capitalized. For example, `\"America\" < \"Brazil\"` is not affected (it's always true), and neither is `\"america\" < \"brazil\"` (always true too); since the first letter is consistently capitalized. But, whether `\"america\" < \"Brazil\"` (the words are not consistently capitalized) is true or false in base R depends on the locale of your R session. In America it is true by default and false if you i) type `Sys.setlocale(locale=\"C\")`, ii) the R session has been started in a C locale for you which can happen on servers/services (the locale comes from the environment the R session is started in). However, `\"america\" < \"Brazil\"` is always, consistently false in data.table which can be a surprise because it differs to base R by default in most regions. It is false because `\"B\"<\"a\"` is true because all upper-case letters come first, followed by all lower case letters (the ascii number of each letter determines the order, which is what is meant by `C-locale`).\n\n9. `data.table`'s dependency has been moved forward from R 3.0.0 (Apr 2013) to R 3.1.0 (Apr 2014; i.e. 3.5 years old). We keep this dependency as old as possible for as long as possible as requested by users in managed environments. Thanks to Jan Gorecki, the test suite from latest dev now runs on R 3.1.0 continuously, as well as R-release (currently 3.4.2) and latest R-devel snapshot. The primary motivation for the bump to R 3.1.0 was allowing one new test which relies on better non-copying behaviour in that version, [#2484](https://github.com/Rdatatable/data.table/issues/2484). It also allows further internal simplifications. Thanks to @MichaelChirico for fixing another test that failed on R 3.1.0 due to slightly different behaviour of `base::read.csv` in R 3.1.0-only which the test was comparing to, [#2489](https://github.com/Rdatatable/data.table/pull/2489).\n\n10. New vignette added: _Importing data.table_ - focused on using data.table as a dependency in R packages. Answers most commonly asked questions and promote good practices.\n\n11. As warned in v1.9.8 release notes below in this file (25 Nov 2016) it has been 1 year since then and so use of `options(datatable.old.unique.by.key=TRUE)` to restore the old default is now deprecated with warning. The new warning states that this option still works and repeats the request to pass `by=key(DT)` explicitly to `unique()`, `duplicated()`, `uniqueN()` and `anyDuplicated()` and to stop using this option. In another year, this warning will become error. Another year after that the option will be removed.\n\n12. As `set2key()` and `key2()` have been warning since v1.9.8 (Nov 2016), their warnings have now been upgraded to errors. Note that when they were introduced in version 1.9.4 (Oct 2014) they were marked as 'experimental' in NEWS item 4. They will be removed in one year.\n\n ```\n Was warning: set2key() will be deprecated in the next release. Please use setindex() instead.\n Now error: set2key() is now deprecated. Please use setindex() instead.\n ```\n\n---\n\nback to data.table after a long time with dplyr #rstats\n\n25 Dec 2014 Hadley Wickham on Hacker News\n\nData tables are extremely fast but I think their concision makes it harder to learn and code that uses it is harder to read after you've written it. It's very reminiscent of APL.\n\nOur response: See the hacker news item and comparing dplyr to data.table on Stack Overflow. The word reminiscent was used to convey the notion of-the-past and is meant as criticism. Note that Hadley was responding to a positive post about data.table on Hacker News. The original item was :\n\nAnyone doing R comparisons should use data.table instead of data.frame. More so for benchmarks. data.table is the best data structure/query language I have found in my career. It's leading the way in The R world, and in my way, in all the data-focused languages.\n\nHadley sought to shoot down this positive sentiment. His negative sentiment is what has stuck in the community rather than the original post which was positive. That's what works.\n\n26 Jun 2014 Hadley Wickham on Stack Overflow\n\nAlso read.csv() reads everything into a big character matrix and then modifies that, does fread() do the same thing? In fastread we guess column types and then coerce as we go to avoid a complete copy of the df.\n\nThe Stack Overflow question is \"Reason behind speed of fread in data.table package in R\" and an implicit compliment to data.table. That's the context. The comment is a subtle way to i) create doubt about fread and ii) announce his new fastread package which had not been known before that. fastread subsequently became readr.\n\n---\n\n#include \"data.table.h\"\n\n/*\nImplements binary search (a.k.a. divide and conquer).\nhttp://en.wikipedia.org/wiki/Binary_search\nhttp://www.tbray.org/ongoing/When/200x/2003/03/22/Binary\nhttp://googleresearch.blogspot.com/2006/06/extra-extra-read-all-about-it-nearly.html\nDifferences over standard binary search (e.g. bsearch in stdlib.h) :\n o list of vectors (key of many columns) of different types\n o ties (groups)\n o NA,NAN,-Inf,+Inf are distinct values and can be joined to\n o type double is joined within tolerance (apx 11 s.f.) according to setNumericRounding (default off)\n o join to prevailing value (roll join a.k.a locf), forwards or backwards\n o join to nearest\n o roll the beginning and end optionally\n o limit the roll distance to a user provided value\n o non equi joins (no != yet) since 1.9.8\n*/\n\n#define EQ 1\n#define LE 2\n#define LT 3\n#define GE 4\n#define GT 5\n\nstatic const SEXP *idtVec, *xdtVec;\nstatic const int *icols, *xcols;\nstatic SEXP nqgrp;\nstatic int ncol, *o, *xo, *retFirst, *retLength, *retIndex, *allLen1, *allGrp1, *rollends, ilen, anslen;\nstatic int *op, nqmaxgrp;\nstatic int ctr, nomatch; // populating matches for non-equi joins\nenum {ALL, FIRST, LAST, ERR} mult = ALL;\nstatic double roll, rollabs;\nstatic Rboolean rollToNearest=FALSE;\n#define XIND(i) (xo ? xo[(i)]-1 : i)\n\nvoid bmerge_r(int xlowIn, int xuppIn, int ilowIn, int iuppIn, int col, int thisgrp, int lowmax, int uppmax);\n\nSEXP bmerge(SEXP idt, SEXP xdt, SEXP icolsArg, SEXP xcolsArg, SEXP xoArg, SEXP rollarg, SEXP rollendsArg, SEXP nomatchArg, SEXP multArg, SEXP opArg, SEXP nqgrpArg, SEXP nqmaxgrpArg) {\n const bool verbose = GetVerbose();\n double tic=0.0, tic0=0.0;\n if (verbose)\n tic = omp_get_wtime();\n int xN, iN, protecti=0;\n ctr=0; // needed for non-equi join case\n SEXP retFirstArg, retLengthArg, retIndexArg, allLen1Arg, allGrp1Arg;\n retFirstArg = retLengthArg = retIndexArg = R_NilValue; // suppress gcc msg\n\n---\n\nSee \\href{../doc/datatable-intro.html}{\\code{vignette(\"datatable-intro\")}} and \\code{example(data.table)}.}\n\n \\item{by}{ Column names are seen as if they are variables (as in \\code{j} when \\code{with=TRUE}). The \\code{data.table} is then grouped by the \\code{by} and \\code{j} is evaluated within each group. The order of the rows within each group is preserved, as is the order of the groups. \\code{by} accepts:\n\n \\itemize{\n \\item A single unquoted column name: e.g., \\code{DT[, .(sa=sum(a)), by=x]}\n\n \\item a \\code{list()} of expressions of column names: e.g., \\code{DT[, .(sa=sum(a)), by=.(x=x>0, y)]}\n\n \\item a single character string containing comma separated column names (where spaces are significant since column names may contain spaces even at the start or end): e.g., \\code{DT[, sum(a), by=\"x,y,z\"]}\n\n \\item a character vector of column names: e.g., \\code{DT[, sum(a), by=c(\"x\", \"y\")]}\n\n \\item or of the form \\code{startcol:endcol}: e.g., \\code{DT[, sum(a), by=x:z]}\n }\n\n \\emph{Advanced:} When \\code{i} is a \\code{list} (or \\code{data.frame} or \\code{data.table}), \\code{DT[i, j, by=.EACHI]} evaluates \\code{j} for the groups in \\code{DT} that each row in \\code{i} joins to. That is, you can join (in \\code{i}) and aggregate (in \\code{j}) simultaneously. We call this \\emph{grouping by each i}. See \\href{https://stackoverflow.com/a/27004566/559784}{this StackOverflow answer} for a more detailed explanation until we \\href{https://github.com/Rdatatable/data.table/issues/944}{roll out vignettes}.\n\n \\emph{Advanced:} In the \\code{X[Y, j]} form of grouping, the \\code{j} expression sees variables in \\code{X} first, then \\code{Y}. We call this \\emph{join inherited scope}. If the variable is not in \\code{X} or \\code{Y} then the calling frame is searched, its calling frame, and so on in the usual way up to and including the global environment.}\n\n \\item{keyby}{ Same as \\code{by}, but with an additional \\code{setkey()} run on the \\code{by} columns of the result, for convenience. It is common practice to use \\code{keyby=} routinely when you wish the result to be sorted. May also be \\code{TRUE} or \\code{FALSE} when \\code{by} is provided as an alternative way to accomplish the same operation.}\n\n \\item{with}{ By default \\code{with=TRUE} and \\code{j} is evaluated within the frame of \\code{x}; column names can be used as variables. In the case of overlapping variable names inside \\code{x} and in parent scope, you can use the double dot prefix \\code{..cols} to explicitly refer to the \\code{cols} variable in parent scope and not from \\code{x}.\n\n When \\code{j} is a character vector of column names, a numeric vector of column positions to select, or of the form \\code{startcol:endcol}, the value returned is always a \\code{data.table}.\n\n New code should rarely use this argument, which was originally needed for similarity to data.frame. For example, to select columns from a character vector \\code{cols}, in data.frame we do \\code{x[, cols]}, which has several equivalents in data.table: \\code{x[, .SD, .SDcols=cols]}, \\code{x[, ..cols]}, \\code{x[, cols, env = list(cols = I(cols))]}, or \\code{x[, cols, with=FALSE]}.}\n\n \\item{nomatch}{ When a row in \\code{i} has no match to \\code{x}, \\code{nomatch=NA} (default) means \\code{NA} is returned. \\code{NULL} (or \\code{0} for backward compatibility) means no rows will be returned for that row of \\code{i}. }\n\n \\item{mult}{ When \\code{i} is a \\code{list} (or \\code{data.frame} or \\code{data.table}) and \\emph{multiple} rows in \\code{x} match to the row in \\code{i}, \\code{mult} controls which are returned: \\code{\"all\"} (default), \\code{\"first\"} or \\code{\"last\"}.}\n\n \\item{roll}{ When \\code{i} is a \\code{data.table} and its row matches to all but the last \\code{x} join column, and its value in the last \\code{i} join column falls in a gap (including after the last observation in \\code{x} for that group), then:\n\n---\n\n6. Using a double vector in `set()`'s `i=` and/or `j=` no longer throws a warning about preferring integer, [#6594](https://github.com/Rdatatable/data.table/issues/6594). While it may improve efficiency to use integer, there's no guarantee it's an improvement and the difference is likely to be minimal. The coercion will still be reported under `datatable.verbose=TRUE`. For package/production use cases, static analyzers such as `lintr::implicit_integer_linter()` can also report when numeric literals should be rewritten as integer literals.\n\n7. In rare situations a data.table object may lose its internal attribute that holds a self-reference. New helper function `.selfref.ok()` tests just that. It is only intended for technical use cases. See manual for examples.\n\n8. Retain important information in the error message about the source of the error when `i=` fails, e.g. pointing to `charToDate()` failing in `DT[date_col == \"20250101\"]`, [#7444](https://github.com/Rdatatable/data.table/issues/7444). Thanks @jan-swissre for the report and @MichaelChirico for the fix.\n\n9. Internal use of declared non-API R functions `SETLENGTH`, `TRUELENGTH`, `SET_TRUELENGTH`, and `SET_GROWABLE_BIT` has been eliminated. Most usages have been migrated to R's experimental resizable vectors API (thanks to @ltierney, introduced in R 4.6.0, backported for older R versions), [#7451](https://github.com/Rdatatable/data.table/pull/7451). Uses of `TRUELENGTH` for marking seen items during grouping and binding operations (aka free hash table trick) have been replaced with proper hash tables, [#6694](https://github.com/Rdatatable/data.table/pull/6694). The new hash table implementation uses linear probing with power of 2 tables and automatic resizing. Additionally, `chmatch()` now hashes the needle (`x`) instead of the haystack (`table`) when `length(table) >> length(x)`, significantly improving performance for lookups into large tables. We've benchmarked the refactored code and find the performance satisfactory, but please do report any edge case performance regressions we may have missed. Thanks to @aitap, @ben-schwen, @jangorecki and @HughParsonage for implementation and reviews.\n\n## data.table [v1.17.8](https://github.com/Rdatatable/data.table/milestone/41) (6 July 2025)\n\n1. Internal functions used to signal errors are now marked as non-returning, silencing a compiler warning about potentially unchecked allocation failure. Thanks to Prof. Brian D. Ripley for the report and @aitap for the fix, [#7070](https://github.com/Rdatatable/data.table/pull/7070).\n\n## data.table [v1.17.6](https://github.com/Rdatatable/data.table/milestone/40) (15 June 2025)\n\n1. On a heavily loaded machine, a `forder` thread could try to perform a zero-length copy from a null pointer, which was de-facto harmless but is against the C standard and was caught by additional CRAN checks, [#7051](https://github.com/Rdatatable/data.table/issues/7051). Thanks to @helske for the report and @aitap for the PR.\n\n## data.table [v1.17.4](https://github.com/Rdatatable/data.table/milestone/39) (25 May 2025)\n\n1. The C code now avoids passing invalid data pointers from 0-length vectors to `memcpy()`, which previously caused undefined behaviour. Thanks to Prof. Brian D. Ripley for the report and Michael Chirico for the fix, [#6911](https://github.com/Rdatatable/data.table/pull/6911).\n\n## data.table [v1.17.2](https://github.com/Rdatatable/data.table/milestone/38) (7 May 2025)\n\n### BUG FIXES\n\n1. `fwrite(compress=\"gzip\")` once again produces a gzip header when the column names are missing or disabled, [@6852](https://github.com/Rdatatable/data.table/issues/6852). Thanks @maxscheiber for the report and @aitap for the fix.\n\n2. `fread(keepLeadingZeros=TRUE)` now correctly parses dates with components with leading zeros as dates instead of strings, [#6851](https://github.com/Rdatatable/data.table/issues/6851). Thanks @TurnaevEvgeny for the report and @ben-schwen for the fix.\n\n---\n\n#: assign.c:453\n#, c-format\nmsgid \"\"\n\"truelength (%d) is greater than 10,000 items over-allocated (length = %d). \"\n\"See ?truelength. If you didn't set the datatable.alloccol option very large, \"\n\"please report to data.table issue tracker including the result of \"\n\"sessionInfo().\"\nmsgstr \"\"\n\"truelength (%d) est supérieur à 10 000 éléments sur-alloués (length = %d). \"\n\"Voir ?truelength. Si vous n'avez pas mis une très grande valeur à l'option \"\n\"datatable.alloccol, veuillez rapporter ce problème dans le gestionnaire de \"\n\"tickets (issue tracker) de data.table en incluant le résultat de \"\n\"sessionInfo().\"\n\n#: assign.c:457\nmsgid \"\"\n\"It appears that at some earlier point, names of this data.table have been \"\n\"reassigned. Please ensure to use setnames() rather than names<- or \"\n\"colnames<-. Otherwise, please report to data.table issue tracker.\"\nmsgstr \"\"\n\"Il semble qu'à un moment donné, les noms de cette table data.table aient été \"\n\"réattribués. Veillez à utiliser setnames() plutôt que names<- ou colnames<-. \"\n\"Dans le cas contraire, signalez le problème dans le gestionnaire de tickets \"\n\"(issue tracker) de data.table.\"\n\n#: assign.c:464\nmsgid \"\"\n\"It appears that at some earlier point, attributes of this data.table have \"\n\"been reassigned. Please use setattr(DT, name, value) rather than attr(DT, \"\n\"name) <- value. If that doesn't apply to you, please report your case to the \"\n\"data.table issue tracker.\"\nmsgstr \"\"\n\"Il semble qu'à un moment donné, les attributs de ce data.table aient été \"\n\"réattribués. Veillez à utiliser setattr(DT, nom, valeur) plutôt que attr(DT, \"\n\"nom) <- valeur. Si cela ne vous concerne pas, veuillez signaler le problème \"\n\"dans le gestionnaire de tickets (issue tracker) de data.table.\"\n\n#: assign.c:496\n#, c-format\nmsgid \"\"\n\"RHS for item %d has been duplicated because MAYBE_REFERENCED==%d \"\n\"MAYBE_SHARED==%d ALTREP==%d, but then is being plonked. length(values)==%d; \"\n\"length(cols)==%d\\n\"\nmsgstr \"\"\n\"Le membre droit (RHS) pour l'élément %d a été dupliqué parce que \"\n\"MAYBE_REFERENCED==%d MAYBE_SHARED==%d ALTREP==%d, mais il est ensuite \"\n\"remplacé ('plonk'). length(values)==%d ; length(cols)==%d\\n\"\n\n#: assign.c:501\n#, c-format\nmsgid \"\"\n\"Direct plonk of unnamed RHS, no copy. MAYBE_REFERENCED==%d, MAYBE_SHARED==\"\n\"%d\\n\"\nmsgstr \"\"\n\"Remplacement ('plonk') du membre de droite (RHS) sans nom, pas de copie. \"\n\"MAYBE_REFERENCED==%d, MAYBE_SHARED==%d\\n\"\n\n#: assign.c:570\n#, c-format\nmsgid \"\"\n\"Dropping index '%s' as it doesn't have '__' at the beginning of its name. It \"\n\"was very likely created by v1.9.4 of data.table.\\n\"\nmsgstr \"\"\n\"Suppression de l'indice '%s' car il n'a pas '__' au début de son nom. Il a \"\n\"très probablement été créé par la version 1.9.4 de data.table.\\n\"\n\n#: assign.c:615 assign.c:631\n#, c-format\nmsgid \"Dropping index '%s' due to an update on a key column\\n\"\nmsgstr \"\"\n\"Suppression de l'indice '%s' suite à une mise à jour d'une colonne clé\\n\"\n\n#: assign.c:624\n#, c-format\nmsgid \"Shortening index '%s' to '%s' due to an update on a key column\\n\"\nmsgstr \"\"\n\"Raccourcissement de l'indice '%s' en '%s' suite à une mise à jour d'une \"\n\"colonne clé\\n\"\n\n#: assign.c:682\n#, c-format\nmsgid \"(column %d named '%s')\"\nmsgstr \"(colonne %d nommée '%s')\"\n\n#: assign.c:716\n#, c-format\nmsgid \"\"\n\"Cannot assign 'factor' to '%s'. Factors can only be assigned to factor, \"\n\"character or list columns.\"\nmsgstr \"\"\n\"Impossible d'affecter 'factor' à '%s'. Les facteurs ne peuvent être affectés \"\n\"qu'à des colonnes de facteurs, de caractères ou de listes.\"\n\n#: assign.c:731\n#, c-format\n#| msgid \"\"\n#| \"Assigning factor numbers to %s. But %d is outside the level range [1,%d]\"\nmsgid \"\"\n\"Assigning factor numbers to target vector. But %d is outside the level range \"\n\"[1,%d]\"\nmsgstr \"\"\n\"Attribution des numéros de facteurs au vecteur cible. Mais %d est en dehors \"\n\"de l'intervalle des niveaux [1,%d]\"\n\n---\n\nR data.table FAQ vignette has been converted to Rmarkdown format and can be found here. It is also shipped together with data.table package, so it can be accessed locally using vignette(\"datatable-faq\", package=\"data.table\").\n\n---\n\nfoverlaps = function(x, y, by.x=key(x) %||% key(y), by.y=key(y), maxgap=0L, minoverlap=1L, type=c(\"any\", \"within\", \"start\", \"end\", \"equal\"), mult=c(\"all\", \"first\", \"last\"), nomatch=NA, which=FALSE, verbose=getOption(\"datatable.verbose\")) {\n\n if (!is.data.table(y) || !is.data.table(x)) stopf(\"y and x must both be data.tables. Use `setDT()` to convert list/data.frames to data.tables by reference or as.data.table() to convert to data.tables by copying.\")\n maxgap = as.integer(maxgap); minoverlap = as.integer(minoverlap)\n which = as.logical(which)\n .unsafe.opt() #3585\n nomatch = if (is.null(nomatch)) 0L else as.integer(nomatch)\n if (!length(maxgap) || length(maxgap) != 1L || is.na(maxgap) || maxgap < 0L)\n stopf(\"maxgap must be a non-negative integer value of length 1\")\n if (!length(minoverlap) || length(minoverlap) != 1L || is.na(minoverlap) || minoverlap < 1L)\n stopf(\"minoverlap must be a positive integer value of length 1\")\n if (!isTRUEorFALSE(which))\n stopf(\"'%s' must be TRUE or FALSE\", \"which\")\n if (!length(nomatch) || length(nomatch) != 1L || (!is.na(nomatch) && nomatch!=0L))\n stopf(\"nomatch must either be NA or NULL\")\n type = match.arg(type)\n mult = match.arg(mult)\n # if (maxgap > 0L || minoverlap > 1L) # for future implementation\n if (maxgap != 0L || minoverlap != 1L)\n stopf(\"maxgap and minoverlap arguments are not yet implemented.\")\n if (is.null(by.y))\n stopf(\"y must be keyed (i.e., sorted, and, marked as sorted). Call setkey(y, ...) first, see ?setkey. Also check the examples in ?foverlaps.\")\n if (length(by.x) < 2L || length(by.y) < 2L)\n stopf(\"'by.x' and 'by.y' should contain at least two column names (or numbers) each - corresponding to 'start' and 'end' points of intervals. Please see ?foverlaps and examples for more info.\")\n if (is.numeric(by.x)) {\n if (any(by.x < 0L) || any(by.x > length(x)))\n stopf(\"Invalid numeric value for 'by.x'; it should be a vector with values 1 <= by.x <= length(x)\")\n by.x = names(x)[by.x]\n }\n if (is.numeric(by.y)) {\n if (any(by.y < 0L) || any(by.y > length(y)))\n stopf(\"Invalid numeric value for 'by.y'; it should be a vector with values 1 <= by.y <= length(y)\")\n by.y = names(y)[by.y]\n }\n if (!is.character(by.x))\n stopf(\"A non-empty vector of column names or numbers is required for '%s'\", \"by.x\")\n if (!is.character(by.y))\n stopf(\"A non-empty vector of column names or numbers is required for '%s'\", \"by.y\")\n if (!identical(by.y, key(y)[seq_along(by.y)]))\n stopf(\"The first %d columns of y's key must be identical to the columns specified in by.y.\", length(by.y))\n if (anyNA(chmatch(by.x, names(x))))\n stopf(\"Elements listed in 'by.x' must be valid names in data.table x\")\n if (anyDuplicated(by.x) || anyDuplicated(by.y))\n stopf(\"Duplicate columns are not allowed in overlap joins. This may change in the future.\")\n if (length(by.x) != length(by.y))\n stopf(\"length(by.x) != length(by.y). Columns specified in by.x should correspond to columns specified in by.y and should be of same lengths.\")\n\n #1730 - handling join possible but would require workarounds on setcolorder further, it is really better just to rename dup column\n check_duplicate_names(x)\n check_duplicate_names(y)\n\n---\n\n* gains argument `strip.white` which is `TRUE` by default (unlike `base::read.table`). All unquoted columns' leading and trailing white spaces are automatically removed. If \\code{FALSE}, only trailing spaces of header is removed. Closes [#1113](https://github.com/Rdatatable/data.table/issues/1113), [#1035](https://github.com/Rdatatable/data.table/issues/1035), [#1000](https://github.com/Rdatatable/data.table/issues/1000), [#785](https://github.com/Rdatatable/data.table/issues/785), [#529](https://github.com/Rdatatable/data.table/issues/529) and [#956](https://github.com/Rdatatable/data.table/issues/956). Thanks to @dmenne, @dpastoor, @GHarmata, @gkalnytskyi, @renqian, @MatthewForrest, @fxi and @heraldb.\n * doesn't warn about empty lines when 'nrow' argument is specified and that many rows are read properly. Thanks to @richierocks for the report. Closes [#1330](https://github.com/Rdatatable/data.table/issues/1330).\n * doesn't error/warn about not being able to read last 5 lines when 'nrow' argument is specified. Thanks to @robbig2871. Closes [#773](https://github.com/Rdatatable/data.table/issues/773).\n\n---\n\nTambién puede usar solo un subconjunto de las funciones de `data.table`; por ejemplo, algunos paquetes pueden usar simplemente el lector y escritor de CSV de alto rendimiento de `data.table`, para lo cual puede agregar `importFrom(data.table, fread, fwrite)` en su archivo `NAMESPACE`. También es posible importar todas las funciones de un paquete, *excluyendo* algunas específicas, usando `import(data.table, except=c(fread, fwrite))`.\n\nAsegúrese de leer también la nota sobre la evaluación no estándar en `data.table` en [la sección sobre \"globales indefinidos\"](#globals).\n\n## Uso\n\nComo ejemplo, definiremos dos funciones en el paquete `a.pkg` que utilizan `data.table`. Una función, `gen`, generará un `data.table` simple; otra, `aggr`, realizará una agregación simple del mismo.\n\n```r\ngen = function (n = 100L) {\n dt = as.data.table(list(id = seq_len(n)))\n dt[, grp := ((id - 1) %% 26) + 1\n ][, grp := letters[grp]\n ][]\n}\naggr = function (x) {\n stopifnot(\n is.data.table(x),\n \"grp\" %in% names(x)\n )\n x[, .N, by = grp]\n}\n```\n\n## Pruebas\n\nAsegúrese de incluir pruebas en su paquete. Antes de cada lanzamiento principal de `data.table`, verificamos las dependencias inversas. Esto significa que si algún cambio en `data.table` pudiera afectar su código, podremos detectar los cambios problemáticos e informarle antes de publicar la nueva versión. Esto, por supuesto, supone que publicará su paquete en CRAN o Bioconductor. La prueba más básica puede ser un script de R en texto plano en el directorio `tests/test.R` de su paquete:\n\n```r\nlibrary(a.pkg)\ndt = gen()\nstopifnot(nrow(dt) == 100)\ndt2 = aggr(dt)\nstopifnot(nrow(dt2) < 100)\n```\n\nAl probar su paquete, puede utilizar `R CMD check --no-stop-on-test-error`, que continuará después de un error y ejecutará todas sus pruebas (en lugar de detenerse en la primera línea del script que falló).\n\n## Pruebas usando `testthat`\n\nEs muy común usar el paquete `testthat` para realizar pruebas. Probar un paquete que importa `data.table` no es diferente a probar otros paquetes. Un ejemplo de script de prueba `tests/testthat/test-pkg.R`:\n\n```r\ncontext(\"pkg tests\")\n\ntest_that(\"generate dt\", { expect_true(nrow(gen()) == 100) })\ntest_that(\"aggregate dt\", { expect_true(nrow(aggr(gen())) < 100) })\n```\n\nSi `data.table` está en \"Suggests\" (pero no en \"Imports\"), entonces necesita declarar `.datatable.aware=TRUE` en uno de los archivos R/* para evitar errores de \"objeto no encontrado\" al realizar pruebas a través de `testthat::test_package` o `testthat::test_check`.\n\n## Cómo lidiar con \"undefined global functions or variables \" {#globals}\n\nEl uso de la evaluación diferida de R por parte de `data.table` (especialmente en el lado izquierdo de `:=`) no es bien reconocido por `R CMD check`. Esto genera `NOTE`s como la siguiente durante la comprobación del paquete:\n\n```\n* checking R code for possible problems ... NOTE\naggr: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'grp'\ngen: no visible binding for global variable 'id'\nUndefined global functions or variables:\ngrp id\n```\n\nLa forma más sencilla de solucionar esto es predefinir esas variables dentro del paquete y establecerlas como `NULL`, añadiendo opcionalmente un comentario (como se hace en la versión refinada de `gen` a continuación). Siempre que sea posible, también puede usar un vector de caracteres en lugar de símbolos (como en `aggr` a continuación):\n\n```r\ngen = function (n = 100L) {\n id = grp = NULL # due to NSE notes in R CMD check\n dt = as.data.table(list(id = seq_len(n)))\n dt[, grp := ((id - 1) %% 26) + 1\n ][, grp := letters[grp]\n ][]\n}\naggr = function (x) {\n stopifnot(\n is.data.table(x),\n \"grp\" %in% names(x)\n )\n x[, .N, by = \"grp\"]\n}\n```\n\n---\n\nUna versión futura de data.table podría permitir distinguir entre una clave y una *clave única*. Internamente, `mult = \"all\"` funcionaría de forma similar a `mult = \"first\"` cuando todas las columnas de la clave de `x` estuvieran unidas y la clave de `x` fuera única. data.table necesitaría comprobaciones al insertar y actualizar para garantizar que se mantenga una clave única. Una ventaja de especificar una clave única sería que, además de mejorar el rendimiento, data.table garantizaría que no se insertaran duplicados.\n\n## Estoy usando `c()` en `j` y obtengo resultados extraños.\n\nEsta es una fuente común de confusión. En `data.frame` se suele usar, por ejemplo:\n\n```{r}\nDF = data.frame(x = 1:3, y = 4:6, z = 7:9)\nDF\nDF[ , c(\"y\", \"z\")]\n```\n\nQue devuelve las dos columnas. En data.table, sabe que puede usar los nombres de las columnas directamente y podría intentar:\n\n```{r}\nDT = data.table(DF)\nDT[ , c(y, z)]\n```\n\nPero esto devuelve un vector. Recuerde que la expresión `j` se evalúa en el entorno de `DT` y `c()` devuelve un vector. Si se requieren dos o más columnas, utilice `list()` o `.()` en su lugar:\n\n```{r}\nDT[ , .(y, z)]\n```\n\n`c()` también puede ser útil en una data.table, pero su comportamiento es diferente al de `[.data.frame`.\n\n## He creado una tabla compleja con muchas columnas. Quiero usarla como plantilla para una nueva tabla; es decir, crear una tabla sin filas, pero con los nombres y tipos de columna copiados de mi tabla. ¿Es fácil hacerlo?\n\nSí. Si su tabla compleja se llama `DT`, intente `NEWDT = DT[0]`.\n\n## ¿Es un data.table nulo lo mismo que `DT[0]`?\n\nNo. Por \"data.table nulo\" nos referimos al resultado de `data.table(NULL)` o `as.data.table(NULL)`; *es decir*,\n\n```{r}\ndata.table(NULL)\ndata.frame(NULL)\nas.data.table(NULL)\nas.data.frame(NULL)\nis.null(data.table(NULL))\nis.null(data.frame(NULL))\n```\n\nEl objeto data.table|`frame` nulo es `NULL` con algunos atributos adjuntos, lo que significa que ya no es `NULL`. En R, solo `NULL` puro es `NULL`, como se prueba con `is.null()`. Al referirnos al objeto \"data.table\" nulo, usamos `null` en minúscula para distinguirlo de `NULL` en mayúscula. Para comprobar si el objeto data.table es nulo, use `length(DT) == 0` o `ncol(DT) == 0` (`length` es ligeramente más rápido, ya que es una función primitiva).\n\nUna data.table *vacía* (`DT[0]`) tiene una o más columnas, todas ellas vacías. Estas columnas vacías aún conservan nombres y tipos.\n\n```{r}\nDT = data.table(a = 1:3, b = c(4, 5, 6), d = c(7L,8L,9L))\nDT[0]\nsapply(DT[0], class)\n```\n\n## ¿Por qué se ha eliminado el alias `DT()`? {#DTremove1}\n\n`DT` se introdujo originalmente como contenedor para una lista de expresiones `j`. Dado que `DT` era un alias de data.table, era una forma práctica de gestionar el reciclaje silencioso en casos en que cada elemento de la lista `j` evaluaba con longitudes diferentes. Sin embargo, el alias era una de las razones por las que la agrupación era lenta.\n\nA partir de la v1.3, se deben pasar `list()` o `.()` al argumento `j`. Esto es mucho más rápido, especialmente cuando hay muchos grupos. Internamente, este cambio no fue trivial. El reciclaje de vectores ahora se realiza internamente, junto con otras mejoras de velocidad para la agrupación.\n\n## Pero mi código usa `j = DT(...)` y funciona. Las preguntas frecuentes anteriores indican que se ha eliminado `DT()`. {#DTremove2}\n\nEntonces estás usando una versión anterior a la 1.5.3. Antes de la 1.5.3, `[.data.table` detectaba el uso de `DT()` en `j` y lo reemplazaba automáticamente con una llamada a `list()`. Esto facilitaba la transición para los usuarios existentes.\n\n## ¿Cuáles son las reglas de alcance para las expresiones 'j'?\n\nPiense en el subconjunto como un entorno donde todos los nombres de columna son variables. Cuando se utiliza la variable `foo` en la `j` de una consulta como `X[Y, sum(foo)]`, se busca `foo` en el siguiente orden:\n\n---\n\nAhora funciona la sintaxis más natural:\n\n```{r}\nif (packageVersion(\"data.table\") >= \"1.8.1\") {\n DT[ , .N, by = list(a, b)][ , unique(N), by = a]\n }\nif (packageVersion(\"data.table\") >= \"1.9.3\") {\n DT[ , .N, by = .(a, b)][ , unique(N), by = a] # same\n}\n```\n\n# Mensajes de advertencia\n\n## \"Los siguientes objetos están enmascarados de `paquete:base`: `cbind`, `rbind`\"\n\nEsta advertencia solo aparecía en las versiones 1.6.5 y 1.6.6 al cargar el paquete. El objetivo era permitir que `cbind(DT, DF)` funcionara, pero resultó que esto interrumpía la compatibilidad total con el paquete `IRanges`. Actualice a la versión 1.6.7 o posterior.\n\n## \"Se convirtió el RHS numérico a entero para que coincida con el tipo de la columna\"\n\nEspero que esto se explique por sí solo. El mensaje completo es:\n\nSe ha convertido el RHS numérico a entero para que coincida con el tipo de la columna; puede tener precisión truncada. Cambie la columna a numérica primero creando un nuevo vector numérico de longitud 5 (n filas de toda la tabla) y asignándolo (es decir, \"reemplazar columna\"), o convierta el RHS a entero (por ejemplo, 1L o as.integer) para aclarar su intención (y para mayor rapidez). O bien, configure el tipo de columna correctamente desde el principio al crear la tabla y manténgalo.\n\nPara generarlo, prueba:\n\n```{r}\nDT = data.table(a = 1:5, b = 1:5)\nsuppressWarnings(\nDT[2, b := 6] # works (slower) with warning\n)\nclass(6) # numeric not integer\nDT[2, b := 7L] # works (faster) without warning\nclass(7L) # L makes it an integer\nDT[ , b := rnorm(5)] # 'replace' integer column with a numeric column\n```\n\n## Lectura de data.table desde un archivo RDS o RData\n\n`*.RDS` y `*.RData` son tipos de archivo que permiten almacenar objetos R en memoria en disco de forma eficiente. Sin embargo, al almacenar `data.table` en un archivo binario, se pierde la sobreasignación de columnas (véase también `?truelength`). Esto no supone un gran problema: su `data.table` se copiará en memoria en la siguiente operación *por referencia* y generará una advertencia. Por lo tanto, se recomienda ejecutar `setDT()` en cada `data.table` cargado con `readRDS()` o `load()` para restaurar sus atributos internos. Si solo necesita preasignar espacio para nuevas columnas, también puede usar `setalloccol()`.\n\nPara obtener más detalles, consulte `?setDT` y `?truelength`.\n\n# Preguntas generales sobre el paquete\n\n## ¿Parece que la versión v1.3 falta en el archivo CRAN?\n\nAsí es. La versión 1.3 solo estaba disponible en R-Forge. Se implementaron varios cambios importantes internamente, y las pruebas en desarrollo llevaron tiempo.\n\n## ¿Es data.table compatible con S-plus?\n\nNo actualmente.\n\n - Algunas partes principales del paquete están escritas en C y utilizan funciones y estructuras internas de R.\n - El paquete utiliza alcance léxico, que es una de las diferencias entre R y **S-plus** explicadas en [R FAQ 3.3.1](https://cran.r-project.org/doc/FAQ/R-FAQ.html#Lexical-scoping)\n\n## ¿Está disponible para Linux, Mac y Windows?\n\nSí, tanto para 32 bits como para 64 bits en todas las plataformas. Gracias a CRAN. No se utilizan bibliotecas especiales ni específicas del sistema operativo.\n\n## Me parece genial. ¿Qué puedo hacer?\n\nEnvíe sugerencias, informes de errores y solicitudes de mejora a nuestro [seguimiento de problemas](https://github.com/Rdatatable/data.table/issues). Esto contribuye a mejorar el paquete.\n\nPor favor, marque el paquete con una estrella en [GitHub](https://github.com/Rdatatable/data.table). Esto anima a los desarrolladores y ayuda a otros usuarios de R a encontrarlo.\n\nPuede enviar solicitudes de extracción para cambiar el código y/o la documentación usted mismo; consulte nuestras [Pautas de contribución](https://github.com/Rdatatable/data.table/blob/master/.github/CONTRIBUTING.md).\n\n## No me parece bien. ¿Cómo puedo advertir a los demás sobre mi experiencia?\n\n---\n\n#: data.table.R:139\n#, c-format\nmsgid \"Item '%s' not found in names of input list\"\nmsgstr \"Élément '%s' non trouvé parmi les noms de la liste d'entrée\"\n\n#: data.table.R:159\n#, c-format\nmsgid \"\"\n\"[ was called on a data.table in an environment that is not data.table-aware \"\n\"(i.e. cedta()), but '%s' was used, implying the owner of this call really \"\n\"intended for data.table methods to be called. See vignette('datatable-\"\n\"importing') for details on properly importing data.table.\"\nmsgstr \"\"\n\"[ a été appelé sur un data.table dans un environnement qui n'est pas \"\n\"compatible avec data.table (i.e. cedta()), mais '%s' a été utilisé, ce qui \"\n\"implique que le propriétaire de cet appel avait vraiment l'intention \"\n\"d'appeler des méthodes data.table. Voir la vignette('datatable-importing') \"\n\"pour plus de détails sur l’importation correcte de data.table.\"\n\n#: data.table.R:170\n#, c-format\nmsgid \"verbose must be logical or integer\"\nmsgstr \"verbose doit être soit un booléen, soit un entier\"\n\n#: data.table.R:171\n#, c-format\nmsgid \"verbose must be length 1 non-NA\"\nmsgstr \"verbose doit être de longueur 1 et différent de NA\"\n\n#: data.table.R:179\n#, c-format\nmsgid \"Ignoring by/keyby because 'j' is not supplied\"\nmsgstr \"L'argument by ou keyby est ignoré car 'j' n'est pas fourni\"\n\n#: data.table.R:193\n#, c-format\nmsgid \"When by and keyby are both provided, keyby must be TRUE or FALSE\"\nmsgstr \"\"\n\"Si by et keyby sont fournis simultanément, keyby doit être TRUE ou FALSE\"\n\n#: data.table.R:196 data.table.R:261 data.table.R:351\nmsgid \"Argument '%s' after substitute: %s\"\nmsgstr \"Argument '%s' après substitution : %s\"\n\n#: data.table.R:205\n#, c-format\nmsgid \"\"\n\"When on= is provided but not i=, on= must be a named list or data.table|\"\n\"frame, and a natural join (i.e. join on common names) is invoked. Ignoring \"\n\"on= which is '%s'.\"\nmsgstr \"\"\n\"Lorsque on= est fourni mais pas i=, on= doit être une liste nommée ou un \"\n\"data.table|frame, et une jointure naturelle (c'est-à-dire une jointure sur \"\n\"les noms communs) est invoquée. La valeur de on= qui est '%s' est ignorée.\"\n\n#: data.table.R:218\n#, c-format\nmsgid \"\"\n\"i and j are both missing so ignoring the other arguments. This warning will \"\n\"be upgraded to error in future.\"\nmsgstr \"\"\n\"i et j sont tous les deux absents, donc les autres arguments sont ignorés. \"\n\"Cet avertissement deviendra une erreur à l'avenir.\"\n\n#: data.table.R:222\n#, c-format\nmsgid \"mult argument can only be 'first', 'last', 'all' or 'error'\"\nmsgstr \"l'argument mult ne peut valoir que 'first', 'last', 'all' ou 'error'\"\n\n#: data.table.R:224\n#, c-format\nmsgid \"\"\n\"roll must be a single TRUE, FALSE, positive/negative integer/double \"\n\"including +Inf and -Inf or 'nearest'\"\nmsgstr \"\"\n\"roll doit être une seule valeur TRUE, FALSE, un entier ou un double, positif \"\n\"ou négatif, +Inf, -Inf ou 'nearest' compris\"\n\n#: data.table.R:226\n#, c-format\nmsgid \"roll is '%s' (type character). Only valid character value is 'nearest'.\"\nmsgstr \"\"\n\"roll vaut '%s' (de type caractère). La seule chaîne valide est 'nearest'.\"\n\n#: data.table.R:231\n#, c-format\nmsgid \"rollends must be a logical vector\"\nmsgstr \"rollends doit être un vecteur de booléens\"\n\n#: data.table.R:232\n#, c-format\nmsgid \"rollends must be length 1 or 2\"\nmsgstr \"rollends doit être de longueur 1 ou 2\"\n\n#: data.table.R:240\n#, c-format\nmsgid \"\"\n\"nomatch= must be either NA or NULL (or 0 for backwards compatibility which \"\n\"is the same as NULL but please use NULL)\"\nmsgstr \"\"\n\"nomatch= doit valoir soit NA, soit NULL (ou 0 pour la compatibilité arrière \"\n\"qui équivaut à NULL, mais utiliser NULL dorénavant)\"\n\n#: data.table.R:243\n#, c-format\nmsgid \"which= must be a logical vector length 1. Either FALSE, TRUE or NA.\"\nmsgstr \"\"\n\"which= doit être un vecteur de booléens de longueur 1. Valeur FALSE, TRUE ou \"\n\"NA.\"\n\n---\n\nNote also that you should consider these symbols read-only and of limited scope -- internal data.table code might manipulate them in unexpected ways, and as such their bindings are locked. There are subtle ways to wind up with the wrong object, especially when attempting to copy their values outside a grouping context. See examples; when in doubt, \\code{copy()} is your friend.\n}\n\\seealso{\n \\code{\\link{data.table}}, \\code{\\link{:=}}, \\code{\\link{set}}, \\code{\\link{datatable-optimize}}\n}\n\\examples{\nDT = data.table(x=rep(c(\"b\",\"a\",\"c\"),each=3), v=c(1,1,1,2,2,1,1,2,2), y=c(1,3,6), a=1:9, b=9:1)\nDT\nX = data.table(x=c(\"c\",\"b\"), v=8:7, foo=c(4,2))\nX\n\nDT[.N] # last row, only special symbol allowed in 'i'\nDT[, .N] # total number of rows in DT\nDT[, .N, by=x] # number of rows in each group\nDT[, .SD, .SDcols=x:y] # select columns 'x' through 'y'\nDT[, .SD[1]] # first row of all columns\nDT[, .SD[1], by=x] # first row of all columns for each group in 'x'\nDT[, c(.N, lapply(.SD, sum)), by=x] # get rows *and* sum all columns by group\nDT[, .I[1], by=x] # row number in DT corresponding to each group\nDT[, .N, by=rleid(v)] # get count of consecutive runs of 'v'\nDT[, c(.(y=max(y)), lapply(.SD, min)),\n by=rleid(v), .SDcols=v:b] # compute 'j' for each consecutive runs of 'v'\nDT[, grp := .GRP, by=x] # add a group counter\nDT[, grp_pct := .GRP/.NGRP, by=x] # add a group \"progress\" counter\nX[, DT[.BY, y, on=\"x\"], by=x] # join within each group\nDT[X, on=.NATURAL] # join X and DT on common column similar to X[on=Y]\n\n# .N can be different in i and j\nDT[{cat(sprintf('in i, .N is \\%d\\n', .N)); a < .N/2},\n {cat(sprintf('in j, .N is \\%d\\n', .N)); mean(a)}]\n\n# .I can be different in j and by, enabling rowwise operations in by\nDT[, .(.I, min(.SD[,-1]))]\nDT[, .(min(.SD[,-1])), by=.I]\n\n# Do not expect this to correctly append the value of .BY in each group; copy(.BY) will work.\nby_tracker = list()\nDT[, { append(by_tracker, .BY); sum(v) }, by=x]\n}\n\\keyword{ data }\n\n---\n\n\\code{IDateTime} takes a date-time input and returns a data table with\ncolumns \\code{date} and \\code{time}.\n\nUsing integer storage allows dates and/or times to be used as data table\nkeys. With positive integers with a range less than 100,000, grouping\nand sorting is fast because radix sorting can be used (see\n\\code{sort.list}).\n\nSeveral convenience functions like \\code{hour} and \\code{quarter} are\nprovided to group or extract by hour, month, and other date-time\nintervals. \\code{as.POSIXlt} is also useful. For example,\n\\code{as.POSIXlt(x)$mon} is the integer month. The R base convenience\nfunctions \\code{weekdays}, \\code{months}, and \\code{quarters} can also\nbe used, but these return character values, so they must be converted to\nfactors for use with data.table. \\code{isoweek} is ISO 8601-consistent.\n\nThe \\code{round} method for IDate's is useful for grouping and plotting.\nIt can round to weeks, months, quarters, and years. Similarly, the \\code{round}\nand \\code{trunc} methods for ITime's are useful for grouping and plotting.\nThey can round or truncate to hours and minutes.\nNote for ITime's with 30 seconds, rounding is inconsistent due to rounding off a 5.\nSee 'Details' in \\code{\\link{round}} for more information.\n\nFunctions like \\code{week()} and \\code{isoweek()} provide week numbering functionality.\n\\code{week()} computes completed or fractional weeks within the year,\nwhile \\code{isoweek()} calculates week numbers according to ISO 8601 standards,\nwhich specify that the first week of the year is the one containing the first Thursday.\nThis convention ensures that week boundaries align consistently with year boundaries,\naccounting for both year transitions and varying day counts per week.\n\nSimilarly, \\code{isoyear()} returns the ISO 8601 year corresponding to the ISO week.\n\n}\n\n\\value{\n For \\code{as.IDate}, a class of \\code{IDate} and \\code{Date} with the\n date stored as the number of days since some origin.\n\n For \\code{as.ITime}, a class of \\code{ITime}\n stored as the number of seconds in the day.\n\n For \\code{IDateTime}, a data table with columns \\code{idate} and\n \\code{itime} in \\code{IDate} and \\code{ITime} format.\n\n \\code{second}, \\code{minute}, \\code{hour}, \\code{yday}, \\code{wday},\n \\code{mday}, \\code{week}, \\code{isoweek}, \\code{isoyear}, \\code{month}, \\code{quarter},\n and \\code{year} return integer values\n for second, minute, hour, day of year, day of week,\n day of month, week, month, quarter, and year, respectively.\n \\code{yearmon} and \\code{yearqtr} return double values representing\n respectively \\code{year + (month-1) / 12} and \\code{year + (quarter-1) / 4}.\n\n \\code{second}, \\code{minute}, \\code{hour} are taken directly from\n the \\code{POSIXlt} representation.\n All other values are computed from the underlying integer representation\n and comparable with the values of their \\code{POSIXlt} representation\n of \\code{x}, with the notable difference that while \\code{yday}, \\code{wday},\n and \\code{mon} are all 0-based, here they are 1-based.\n\n}\n\\references{\n\n G. Grothendieck and T. Petzoldt, \\dQuote{Date and Time Classes in R},\n R News, vol. 4, no. 1, June 2004.\n\n H. Wickham, https://gist.github.com/hadley/10238.\n\n ISO 8601, https://www.iso.org/iso/home/standards/iso8601.htm\n}\n\n\\author{ Tom Short, t.short@ieee.org }\n\n\\seealso{ \\code{\\link{as.Date}}, \\code{\\link{as.POSIXct}},\n \\code{\\link{strptime}}, \\code{\\link{DateTimeClasses}}\n\n}\n\n\\examples{\n\n# create IDate:\n(d <- as.IDate(\"2001-01-01\"))\n\n# S4 coercion also works\nidentical(as.IDate(\"2001-01-01\"), methods::as(\"2001-01-01\", \"IDate\"))\n\n# create ITime:\n(t <- as.ITime(\"10:45\"))\n\n# S4 coercion also works\nidentical(as.ITime(\"10:45\"), methods::as(\"10:45\", \"ITime\"))\n\n(t <- as.ITime(\"10:45:04\"))\n\n(t <- as.ITime(\"10:45:04\", format = \"\\%H:\\%M:\\%S\"))\n\n# \"24:00:00\" is parsed as \"00:00:00\"\nas.ITime(\"24:00:00\")\n\n# Workaround for end-of-day: add 1 second to \"23:59:59\"\nas.ITime(\"23:59:59\") + 1L\n\nas.POSIXct(\"2001-01-01\") + as.ITime(\"10:45\")\n\n---\n\n\\code{key} returns the \\code{data.table}'s key if it exists; \\code{NULL} if none exists.\n\n\\code{haskey} returns \\code{TRUE}/\\code{FALSE} if the \\code{data.table} has a key.\n}\n\\usage{\nsetkey(x, \\dots, verbose=getOption(\"datatable.verbose\"), physical = TRUE)\nsetkeyv(x, cols, verbose=getOption(\"datatable.verbose\"), physical = TRUE)\nsetindex(\\dots)\nsetindexv(x, cols, verbose=getOption(\"datatable.verbose\"))\nkey(x)\nindices(x, vectors = FALSE)\nhaskey(x)\n}\n\\arguments{\n\\item{x}{ A \\code{data.table}. }\n\\item{\\dots}{ The columns to sort by. Do not quote the column names. If \\code{\\dots} is missing (i.e. \\code{setkey(DT)}), all the columns are used. \\code{NULL} removes the key. }\n\\item{cols}{ A character vector of column names. For \\code{setindexv}, this can be a \\code{list} of character vectors, in which case each element will be applied as an index in turn. }\n\\item{verbose}{ Output status and information. }\n\\item{physical}{ \\code{TRUE} changes the order of the data in RAM. \\code{FALSE} adds an index. }\n\\item{vectors}{ \\code{logical} scalar, default \\code{FALSE}; when set to \\code{TRUE}, a \\code{list} of character vectors is returned, each referring to one index. }\n}\n\\details{\n\\code{setkey} reorders (i.e. sorts) the rows of a \\code{data.table} by the columns\nprovided. The sort method used has developed over the years and we have contributed\nto base R too; see \\code{\\link[base]{sort}}. Generally speaking we avoid any type\nof comparison sort (other than insert sort for very small input) preferring instead\ncounting sort and forwards radix. We also avoid hash tables.\n\nNote that \\code{setkey} always uses \"C-locale\"; see the Details in the help for \\code{\\link{setorder}} for more on why.\n\nThe sort is \\emph{stable}; i.e., the order of ties (if any) is preserved.\n\nFor character vectors, \\code{data.table} takes advantage of R's internal global string cache, also exported as \\code{\\link{chorder}}.\n}\n\n\\section{Keys vs. Indices}{\nSetting a key (with \\code{setkey}) and an index (with \\code{setindex}) are similar, but have very important distinctions.\n\nSetting a key physically reorders the data in RAM.\n\nSetting an index computes the sort order, but instead of applying the reordering, simply \\emph{stores} this computed ordering. That means that multiple indices can coexist, and that the original row order is preserved.\n}\n\n\\section{Good practice}{\nIn general, it's good practice to use column names rather than numbers. This is\nwhy \\code{setkey} and \\code{setkeyv} only accept column names.\nIf you use column numbers then bugs (possibly silent) can more easily creep into\nyour code as time progresses if changes are made elsewhere in your code; e.g., if\nyou add, remove or reorder columns in a few months time, a \\code{setkey} by column\nnumber will then refer to a different column, possibly returning incorrect results\nwith no warning. (A similar concept exists in SQL, where \\code{\"select * from ...\"} is considered poor programming style when a robust, maintainable system is\nrequired.)\n\nIf you really wish to use column numbers, it is possible but\ndeliberately a little harder; e.g., \\code{setkeyv(DT,names(DT)[1:2])}.\n\nIf you want to subset rows based on values of an integer key column, it should be done with the dot (\\code{.}) syntax, because integers are otherwise interpreted as row numbers (see example).\n\n---\n\n\\section{Development and Verbosity Options}{\n \\describe{\n \\item{\\code{datatable.quiet}}{A logical, default \\code{FALSE}. The master switch to suppress all\n \\code{data.table} status messages, including the startup message.}\n \\item{\\code{datatable.verbose}}{A logical, default \\code{FALSE}. If \\code{TRUE}, \\code{data.table} will\n print detailed diagnostic information as it processes a query.}\n \\item{\\code{datatable.enlist}}{Experimental feature. Default is \\code{NULL}. If set to a function\n (e.g., \\code{list}), the \\code{j} expression can return a \\code{list}, which will then\n be \"enlisted\" into columns in the result.}\n }\n}\n\n\\section{Back-compatibility Options}{\n \\describe{\n \\item{\\code{datatable.old.matrix.autoname}}{Logical, default \\code{FALSE}. Governs how the output of\n expressions like \\code{data.table(x=1, cbind(1))} will be named. When \\code{TRUE}, it will be named\n \\code{V1}, otherwise it will be named \\code{V2}.\n }\n }\n}\n\n\\seealso{\n \\code{\\link[base]{options}},\n \\code{\\link[base]{getOption}},\n \\code{\\link{data.table}}\n}\n\n\\keyword{data}\n\\keyword{utilities}\n\n---\n\n7. Efficient conversion of `xts` to data.table. Closes [#882](https://github.com/Rdatatable/data.table/issues/882). Check examples in `?as.xts.data.table` and `?as.data.table.xts`. Thanks to @jangorecki for the PR.\n\n 8. `rbindlist` gains `idcol` argument which can be used to generate an index column. If `idcol=TRUE`, the column is automatically named `.id`. Instead you can also provide a column name directly. If the input list has no names, indices are automatically generated. Closes [#591](https://github.com/Rdatatable/data.table/issues/591). Also thanks to @KevinUshey for filing [#356](https://github.com/Rdatatable/data.table/issues/356).\n\n 9. A new helper function `uniqueN` is now implemented. It is equivalent to `length(unique(x))` but much faster. It handles `atomic vectors`, `lists`, `data.frames` and `data.tables` as input and returns the number of unique rows. Closes [#884](https://github.com/Rdatatable/data.table/issues/884). Gains by argument. Closes [#1080](https://github.com/Rdatatable/data.table/issues/1080). Closes [#1224](https://github.com/Rdatatable/data.table/issues/1224). Thanks to @DavidArenburg, @kevinmistry and @jangorecki.\n\n 10. Implemented `transpose()` to transpose a list and `tstrsplit` which is a wrapper for `transpose(strsplit(...))`. This is particularly useful in scenarios where a column has to be split and the resulting list has to be assigned to multiple columns. See `?transpose` and `?tstrsplit`, [#1025](https://github.com/Rdatatable/data.table/issues/1025) and [#1026](https://github.com/Rdatatable/data.table/issues/1026) for usage scenarios. Closes both #1025 and #1026 issues.\n * Implemented `type.convert` as suggested by Richard Scriven. Closes [#1094](https://github.com/Rdatatable/data.table/issues/1094).\n\n 11. `melt.data.table`\n * can now melt into multiple columns by providing a list of columns to `measure.vars` argument. Closes [#828](https://github.com/Rdatatable/data.table/issues/828). Thanks to Ananda Mahto for the extended email discussions and ideas on generating the `variable` column.\n * also retains attributes wherever possible. Closes [#702](https://github.com/Rdatatable/data.table/issues/702) and [#993](https://github.com/Rdatatable/data.table/issues/993). Thanks to @richierocks for the report.\n * Added `patterns.Rd`. Closes [#1294](https://github.com/Rdatatable/data.table/issues/1294). Thanks to @MichaelChirico.\n\n 12. `.SDcols`\n * understands `!` now, i.e., `DT[, .SD, .SDcols=!\"a\"]` now works, and is equivalent to `DT[, .SD, .SDcols = -c(\"a\")]`. Closes [#1066](https://github.com/Rdatatable/data.table/issues/1066).\n * accepts logical vectors as well. If length is smaller than number of columns, the vector is recycled. Closes [#1060](https://github.com/Rdatatable/data.table/issues/1060). Thanks to @StefanFritsch.\n\n 13. `dcast` can now:\n * cast multiple `value.var` columns simultaneously. Closes [#739](https://github.com/Rdatatable/data.table/issues/739).\n * accept multiple functions under `fun.aggregate`. Closes [#716](https://github.com/Rdatatable/data.table/issues/716).\n * supports optional column prefixes as mentioned under [this SO post](https://stackoverflow.com/q/26225206/559784). Closes [#862](https://github.com/Rdatatable/data.table/issues/862). Thanks to @JohnAndrews.\n * works with undefined variables directly in formula. Closes [#1037](https://github.com/Rdatatable/data.table/issues/1037). Thanks to @DavidArenburg for the MRE.\n * Naming conventions on multiple columns changed according to [#1153](https://github.com/Rdatatable/data.table/issues/1153). Thanks to @MichaelChirico for the FR.\n * also has a `sep` argument with default `_` for backwards compatibility. [#1210](https://github.com/Rdatatable/data.table/issues/1210). Thanks to @dbetebenner for the FR.\n\n---\n\ntest(11.05, cbindlist(list(data.table(a=1L), data.table(), data.table(d=2L), data.table(f=3L))), data.table(a=1L, d=2L, f=3L))\n## codecov\ntest(12.01, cbindlist(data.frame(a=1L)), error=\"must be a list\")\ntest(12.02, cbindlist(TRUE), error=\"must be a list\")\ntest(12.03, cbindlist(list(data.table(a=1L), 1L)), error=\"is not a data.table\")\ntest(12.04, options = c(datatable.verbose=TRUE), cbindlist(list(data.table(a=1:2), data.table(b=1:2))), data.table(a=1:2, b=1:2), output=\"cbindlist.*took\")\ntest(12.05, cbindlist(list(data.table(), data.table(a=1:2), data.table(b=1:2))), data.table(a=1:2, b=1:2))\ntest(12.06, cbindlist(list(data.table(), data.table(a=1:2), list(b=1:2))), data.table(a=1:2, b=1:2))\ntest(12.07, cbindlist(list(data.table(a=integer()), list(b=integer()))), data.table(a=integer(), b=integer()))\n## duplicated names\ntest(12.08, cbindlist(list(data.table(a=1L, b=2L), data.table(b=3L, d=4L))), data.table(a=1L, b=2L, b=3L, d=4L))\nlocal({\n # also test that keys, indices are wiped\n ans = cbindlist(list(setindexv(data.table(a=2:1, b=1:2), \"a\"), data.table(a=1:2, b=2:1, key=\"a\"), data.table(a=2:1, b=1:2)))\n test(12.09, ans, data.table(a=2:1, b=1:2, a=1:2, b=2:1, a=2:1, b=1:2))\n test(12.10, indices(ans), NULL)\n})\n## recycling, first ensure cbind recycling that we want to match to\ntest(12.11, cbind(data.table(x=integer()), data.table(a=1:2)), data.table(x=c(NA_integer_, NA), a=1:2))\ntest(12.12, cbind(data.table(x=1L), data.table(a=1:2)), data.table(x=c(1L, 1L), a=1:2))\ntest(12.13, cbindlist(list(data.table(a=integer()), data.table(b=1:2))), error=\"Recycling.*not yet implemented\")\ntest(12.14, cbindlist(list(data.table(a=1L), data.table(b=1:2))), error=\"Recycling.*not yet implemented\")\ntest(12.15, setcbindlist(list(data.table(a=integer()), data.table(b=1:2))), error=\"have to have the same number of rows\")\ntest(12.16, setcbindlist(list(data.table(a=1L), data.table(b=1:2))), error=\"have to have the same number of rows\")\n\n## retain indices\nlocal({\n l = list(\n data.table(id1=1:5, id2=5:1, id3=1:5, v1=1:5),\n data.table(id4=5:1, id5=1:5, v2=1:5),\n data.table(id6=5:1, id7=1:5, v3=1:5),\n data.table(id8=5:1, id9=5:1, v4=1:5)\n )\n setkeyv(l[[1L]], \"id1\")\n setindexv(l[[1L]], list(\"id1\", \"id2\", \"id3\", c(\"id1\", \"id2\", \"id3\")))\n setindexv(l[[3L]], list(\"id6\", \"id7\"))\n setindexv(l[[4L]], \"id9\")\n ii = lapply(l, indices)\n ans = cbindlist(l)\n test(13.1, key(ans), \"id1\")\n test(13.2, indices(ans), c(\"id1\", \"id2\", \"id3\", \"id1__id2__id3\", \"id6\", \"id7\", \"id9\"))\n test(13.3, ii, lapply(l, indices)) ## this tests that original indices have not been touched, shallow_duplicate in mergeIndexAttrib\n})\ntest(13.4, cbindlist(list(data.table(a=1:2), data.table(b=3:4, key=\"b\"))), data.table(a=1:2, b=3:4, key=\"b\"))\n# TODO(#7116): this could be supported\n# test(13.5, cbindlist(list(data.table(a=1:2, key=\"a\"), data.table(b=3:4, key=\"b\"))), data.table(a=1:2, b=3:4, key=c(\"a\", \"b\")))\n\n# mergepair\n\n## test copy-ness argument in mergepair\n\n---\n\n## data.table [v1.12.8](https://github.com/Rdatatable/data.table/milestone/15?closed=1) (09 Dec 2019)\n\n### NEW FEATURES\n\n1. `DT[, {...; .(A,B)}]` (i.e. when `.()` is the final item of a multi-statement `{...}`) now auto-names the columns `A` and `B` (just like `DT[, .(A,B)]`) rather than `V1` and `V2`, [#2478](https://github.com/Rdatatable/data.table/issues/2478) [#609](https://github.com/Rdatatable/data.table/issues/609). Similarly, `DT[, if (.N>1) .(B), by=A]` now auto-names the column `B` rather than `V1`. Explicit names are unaffected; e.g. `DT[, {... y= ...; .(A=C+y)}, by=...]` named the column `A` before, and still does. Thanks also to @renkun-ken for his go-first strong testing which caught an issue not caught by the test suite or by revdep testing, related to NULL being the last item, [#4061](https://github.com/Rdatatable/data.table/issues/4061).\n\n### BUG FIXES\n\n1. `frollapply` could segfault and exceed R's C protect limits, [#3993](https://github.com/Rdatatable/data.table/issues/3993). Thanks to @DavisVaughan for reporting and fixing.\n\n2. `DT[, sum(grp), by=grp]` (i.e. aggregating the same column being grouped) could error with `object 'grp' not found`, [#3103](https://github.com/Rdatatable/data.table/issues/3103). Thanks to @cbailiss for reporting.\n\n### NOTES\n\n1. Links in the manual were creating warnings when installing HTML, [#4000](https://github.com/Rdatatable/data.table/issues/4000). Thanks to Morgan Jacob.\n\n2. Adjustments for R-devel (R 4.0.0) which now has reference counting turned on, [#4058](https://github.com/Rdatatable/data.table/issues/4058) [#4093](https://github.com/Rdatatable/data.table/issues/4093). This motivated early release to CRAN because every day CRAN tests every package using the previous day's changes in R-devel; a much valued feature of the R ecosystem. It helps R-core if packages can pass changes in R-devel as soon as possible. Thanks to Luke Tierney for the notice, and for implementing reference counting which we look forward to very much.\n\n3. C internals have been standardized to use `PRI[u|d]64` to print `[u]int64_t`. This solves new warnings from `gcc-8` on Windows with `%lld`, [#4062](https://github.com/Rdatatable/data.table/issues/4062), in many cases already working around `snprintf` on Windows not supporting `%zu`. Release procedures have been augmented to prevent any internal use of `llu`, `lld`, `zu` or `zd`.\n\n4. `test.data.table()` gains `showProgress=interactive()` to suppress the thousands of `Running test id ...` lines displayed by CRAN checks when there are warnings or errors.\n\n\n## data.table [v1.12.6](https://github.com/Rdatatable/data.table/milestone/18?closed=1) (18 Oct 2019)\n\n### BUG FIXES\n\n1. `shift()` on a `nanotime` with the default `fill=NA` now fills a `nanotime` missing value correctly, [#3945](https://github.com/Rdatatable/data.table/issues/3945). Thanks to @mschubmehl for reporting and fixing in PR [#3942](https://github.com/Rdatatable/data.table/pull/3942).\n\n2. Compilation failed on CRAN's MacOS due to an older version of `zlib.h/zconf.h` which did not have `z_const` defined, [#3939](https://github.com/Rdatatable/data.table/issues/3939). Other open-source projects unrelated to R have experienced this problem on MacOS too. We have followed the common practice of removing `z_const` to support the older `zlib` versions, and data.table's release procedures have gained a `grep` to ensure `z_const` isn't used again by accident in future. The library `zlib` is used for `fwrite`'s new feature of multithreaded compression on-the-fly; see item 3 of 1.12.4 below.\n\n---\n\nOtras dos opciones controlan la optimización a nivel global, incluido el uso de índices:\n\n```r\noptions(datatable.optimize=2L)\noptions(datatable.optimize=3L)\n```\n\n`options(datatable.optimize=2L)` desactivará por completo la optimización de filtros, mientras que `options(datatable.optimize=3L)` la reactivará. Estas opciones afectan a muchas más optimizaciones y, por lo tanto, no deben usarse cuando solo se necesita controlar los índices. Más información en `?datatable.optimize`.\n\n# Operaciones *por referencia*\n\nAl comparar funciones `set*`, solo tiene sentido medir la primera ejecución. Estas funciones actualizan su entrada por referencia, por lo que las ejecuciones posteriores utilizarán la `data.table` ya procesada, lo que sesgará los resultados\n\nPara proteger su `data.table` de la actualización por referencia, puede usar las funciones `copy` o `data.table:::shallow`. Tenga en cuenta que `copy` puede ser muy costoso, ya que requiere duplicar el objeto completo. Es poco probable que queramos incluir el tiempo de duplicación en la tarea que estamos evaluando.\n\n# Intentar comparar los procesos atómicos\n\nSi su punto de referencia está destinado a ser publicado, será mucho más esclarecedor si lo divide para medir el tiempo de los procesos atómicos. De esta manera, sus lectores pueden ver cuánto tiempo se dedicó a leer los datos de la fuente, limpiarlos, transformarlos realmente y exportar los resultados. Por supuesto, si su punto de referencia está destinado a presentar un *flujo de trabajo de extremo a extremo*, entonces tiene todo el sentido presentar el tiempo general. Sin embargo, separar el tiempo de los pasos individuales es útil para comprender qué pasos son los principales cuellos de botella de un flujo de trabajo. Hay otros casos en los que el punto de referencia atómico podría no ser deseable, por ejemplo, al *leer un csv*, seguido de *agrupar*. R requiere llenar *la caché de cadena global de R*, lo que agrega sobrecarga adicional al importar datos de caracteres a una sesión de R. Por otro lado, la *caché de cadena global* podría acelerar procesos como *agrupar*. En tales casos, al comparar R con otros lenguajes, podría ser útil incluir el tiempo total.\n\n# Evite la coerción de clase\n\nA menos que esto sea lo que realmente quiera medir, debe preparar objetos de entrada de la clase esperada para cada herramienta que esté evaluando\n\n# evitar `microbenchmark(..., times=100)`\n\nRepetir un benchmark muchas veces no suele ofrecer la imagen más clara para las herramientas de procesamiento de datos. Por supuesto, tiene mucho sentido para cálculos más atómicos, pero esta no es una buena representación de la forma más común en que se utilizarán realmente estas herramientas, es decir, para las tareas de procesamiento de datos, que consisten en lotes de transformaciones proporcionadas secuencialmente, cada una ejecutada una vez. Matt dijo una vez:\n\n> Soy muy cauteloso con los puntos de referencia medidos en tiempos inferiores a 1 segundo. Prefiero 10 segundos o más para una sola ejecución, lo que se logra aumentando el tamaño de los datos. Un recuento de repeticiones de 500 es alarmante. De 3 a 5 ejecuciones deberían ser suficientes para convencer con datos más grandes. La sobrecarga de llamadas y el tiempo de recolección de basura afectan las inferencias a esta escala tan pequeña.\n\nEsto es muy válido. Cuanto menor sea la medición de tiempo, mayor será el ruido relativo. El ruido se genera por el envío de métodos, la inicialización de paquetes/clases, etc. El punto de referencia debe centrarse principalmente en casos de uso reales.\n\n# procesamiento multiproceso\n\nUno de los principales factores que probablemente afecte a los tiempos es el número de subprocesos disponibles para su sesión de R. En versiones recientes de `data.table`, algunas funciones están paralelizadas. Puede controlar el número de subprocesos que desea utilizar con `setDTthreads`\n\n---\n\nDeux autres options permettent de contrôler l'optimisation de manière globale, y compris l'utilisation d'index :\n\n```r\noptions(datatable.optimize=2L)\noptions(datatable.optimize=3L)\n```\n\n`options(datatable.optimize=2L)` désactivera complètement l'optimisation des sous-ensembles, tandis que `options(datatable.optimize=3L)` la réactivera. Ces options affectent beaucoup plus d'optimisations et ne devraient donc pas être utilisées lorsque seul le contrôle des index est nécessaire. Plus d'informations dans `?datatable.optimize`.\n\n# opérations *par référence*\n\nLors de l'évaluation des fonctions `set*`, il n'est utile de mesurer que la première exécution. Ces fonctions mettent à jour leur entrée par référence, donc les exécutions suivantes utiliseront le fichier `data.table` déjà traité, ce qui faussera les résultats.\n\nProtéger votre `data.table` d'une mise à jour par des opérations de référence peut être réalisé en utilisant les fonctions `copy` ou `data.table:::shallow`. Soyez conscient que `copy` peut être très coûteux car il doit dupliquer l'objet entier. Il est peu probable que nous voulions inclure le temps de duplication dans le temps de la tâche réelle que nous benchmarkons.\n\n# tenter d'étalonner les processus atomiques\n\nSi votre analyse comparative est destinée à être publiée, elle sera beaucoup plus utile si vous la divisez pour mesurer la durée des processus atomiques. De cette manière, vos lecteurs pourront voir combien de temps a été consacré à la lecture des données à partir de la source, au nettoyage, à la transformation proprement dite et à l'exportation des résultats. Bien sûr, si votre benchmark est destiné à présenter un *flux de travail de bout en bout*, il est tout à fait logique de présenter le temps global. Néanmoins, la séparation des temps des étapes individuelles est utile pour comprendre quelles étapes sont les principaux goulots d'étranglement d'un flux de travail. Il existe d'autres cas où le benchmarking atomique n'est pas souhaitable, par exemple lors de la *lecture d'un csv*, suivie d'un *regroupement*. R nécessite de remplir le *cache global de chaînes de caractères de R*, ce qui ajoute une surcharge supplémentaire lors de l'importation de données de caractères dans une session R. D'un autre côté, le *cache global de chaînes de caractères* peut accélérer des processus tels que le *regroupement*. Dans de tels cas, lorsque l'on compare R à d'autres langages, il peut être utile d'inclure le temps total.\n\n# éviter la coercition de classe\n\nSi ce n'est pas ce que vous voulez vraiment mesurer, vous devez préparer des objets d'entrée de la classe attendue pour chaque outil que vous comparez.\n\n# éviter `microbenchmark(..., times=100)`\n\nRépéter un benchmark plusieurs fois ne donne généralement pas l'image la plus claire des outils de traitement des données. Bien sûr, c'est parfaitement logique pour les calculs plus atomiques, mais ce n'est pas une bonne représentation de la manière la plus courante dont ces outils seront utilisés, à savoir pour les tâches de traitement des données, qui consistent en des lots de transformations fournies de manière séquentielle, chacune exécutée une fois. Matt a dit un jour :\n\n> Je me méfie beaucoup des benchmarks qui prennent moins d'une seconde. Je préfère de loin 10 secondes ou plus pour une seule exécution, obtenues en augmentant la taille des données. Un nombre de répétitions de 500 tire la sonnette d'alarme. 3 à 5 exécutions devraient suffire à convaincre sur des données plus importantes. Le coût des appels de fonctions et le temps nécessaire au GC affectent les calculs à une si petite échelle.\n\nCeci est tout à fait vrai. Plus la mesure du temps est petite, plus le bruit est important, de manière relative. Le bruit est généré par le dispatching des méthodes, l'initialisation de packages/classes, etc. Le benchmark devrait se concentrer sur des scénarios d'utilisation réelle.\n\n# traitement multithread\n\n---\n\n4. The translations submitted for 1.16.0 are now actually shipped with the package -- our deepest apologies to the translators for the omission. We have added a CI check to ensure that the .mo binaries which get shipped with the package are always up-to-date.\n\n## data.table [v1.16.0](https://github.com/Rdatatable/data.table/milestone/30) (25 August 2024)\n\n### BREAKING CHANGES\n\n1. `droplevels(in.place=TRUE)` is deprecated in favor of calling `setdroplevels()`, [#6014](https://github.com/Rdatatable/data.table/issues/6014). Given the associated risks/pain points, we strongly prefer all in-place/by-reference behavior within data.table come from functions `set*` (and `:=`) to make it as clear as possible that inputs are mutable. See below and `?setdroplevels` for more.\n\n2. `` `[.data.table` `` is un-exported again. This was exported to support an experimental feature (`DT()` functional form of `[`) that never made it to release, but we forgot to claw back this export in the NAMESPACE; sorry about that. We didn't find anyone calling the method directly (which is inadvisable to begin with).\n\n### NEW FEATURES\n\n1. We continue to consider user feedback to prioritize development. See [#3189](https://github.com/Rdatatable/data.table/issues/3189) for the current list of most-requested issues. In this release we add five highly-requested features:\n\n a. Using `dt[, names(.SD) := lapply(.SD, fx)]` now works to update all columns, [#795](https://github.com/Rdatatable/data.table/issues/795). Of course this also works when `.SD` is only a subset of the columns: `dt[, names(.SD) := lapply(.SD, fx), .SDcols = is.numeric]`. Thanks to @brodieG for the report, 20 or so others for chiming in, and @ColeMiller1 for PR.\n\n b. `fread()` now supports automatic detection of `dec` (as either `.` or `,`, the latter being [common in many places in Europe, Africa, and South America](https://en.wikipedia.org/wiki/Decimal_separator)); this behavior is now the default, i.e. `dec='auto'`, [#2431](https://github.com/Rdatatable/data.table/issues/2431). Thanks @mattdowle for the original issue, 50 or more others for expressing support, and @MichaelChirico for the fix.\n\n c. `fcase()` supports vectors in `default=` (so the default can vary by row) and `default=` is now lazily evaluated, [#4258](https://github.com/Rdatatable/data.table/issues/4258). Thanks @sindribaldur for the feature request, @shrektan for doing most of the implementation, and @MichaelChirico for sewing things up. Thanks also to @DavisVaughan for some design guidance before release to remove an extraneous feature, [#6352](https://github.com/Rdatatable/data.table/issues/6352).\n\n d. `[.data.table` gains argument `showProgress`, allowing users to toggle progress printing for slow \"group by\" operations, [#3060](https://github.com/Rdatatable/data.table/issues/3060). The progress bar reports information such as the number of groups processed, total groups, total time elapsed and estimated time until completion. This feature doesn't apply to `GForce`-optimized operations. Thanks to @eatonya and @zachmayer for filing FRs, and to everyone else that up-voted/chimed in on the issue. Thanks to @joshhwuu for the PR.\n\n e. `rbindlist(l, use.names=TRUE)` and `rbind()` now work correctly on columns with different class attributes across the inputs for certain classes such as `Date`, `IDate`, `ITime`, `POSIXct` and `AsIs` with matched columns of similar classes, e.g., `rbind(data.table(d = Sys.Date()), data.table(d = as.IDate(Sys.Date()-1)))`. The conversion is done automatically and the class attribute of the final column is determined by the first class attribute encountered in the binding list, [#5309](https://github.com/Rdatatable/data.table/issues/5309), [#4934](https://github.com/Rdatatable/data.table/issues/4934), [#5391](https://github.com/Rdatatable/data.table/issues/5391).\n\n---\n\n\\name{datatable.optimize}\n\\alias{datatable-optimize}\n\\alias{datatable.optimize}\n\\alias{data.table-optimize}\n\\alias{data.table.optimize}\n\\alias{gforce}\n\\alias{GForce}\n\\alias{autoindex}\n\\alias{autoindexing}\n\\alias{auto-index}\n\\alias{auto-indexing}\n\\alias{rounding}\n\\title{Optimisations in data.table}\n\\description{\n\\code{data.table} internally optimises certain expressions in order to improve\nperformance. This section briefly summarises those optimisations.\n\nNote that there's no additional input needed from the user to take advantage\nof these optimisations. They happen automatically.\n\nRun the code under the \\emph{example} section to get a feel for the performance\nbenefits from these optimisations.\n\nNote that for all optimizations involving efficient sorts, the caveat mentioned\nin \\code{\\link{setorder}} applies -- whenever data.table does the sorting,\nit does so in \"C-locale\". This has some subtle implications; see Examples.\n\n}\n\\details{\n\\code{data.table} reads the global option \\code{datatable.optimize} to figure\nout what level of optimisation is required. The default value \\code{Inf}\nactivates \\emph{all} available optimisations.\n\nFor \\code{getOption(\"datatable.optimize\") >= 1}, these are the optimisations:\n\n\\itemize{\n \\item The base function \\code{order} is internally replaced with\n \\code{data.table}'s \\emph{fast ordering}. That is, \\code{DT[order(\\dots)]}\n gets internally optimised to \\code{DT[forder(\\dots)]}.\n\n \\item The expression \\code{DT[, lapply(.SD, fun), by=.]} gets optimised\n to \\code{DT[, list(fun(a), fun(b), \\dots), by=.]} where \\code{a,b, \\dots} are\n columns in \\code{.SD}. This improves performance tremendously.\n\n \\item Similarly, the expression \\code{DT[, c(.N, lapply(.SD, fun)), by=.]}\n gets optimised to \\code{DT[, list(.N, fun(a), fun(b), \\dots)]}. \\code{.N} is\n just for example here.\n\n \\item \\code{base::mean} function is internally optimised to use\n \\code{data.table}'s \\code{fastmean} function. \\code{mean()} from \\code{base}\n is an S3 generic and gets slow with many groups.\n}\n\nFor \\code{getOption(\"datatable.optimize\") >= 2}, additional optimisations are implemented on top of the optimisations already shown above.\n\n\\itemize{\n\n \\item Expressions in \\code{j} which contain only the functions\n \\code{min, max, mean, median, var, sd, sum, prod, first, last, head, tail} (for example,\n \\code{DT[, list(mean(x), median(x), min(y), max(y)), by=z]}), they are very\n effectively optimised using what we call \\emph{GForce}. These functions\n are automatically replaced with a corresponding GForce version\n with pattern \\code{g*}, e.g., \\code{prod} becomes \\code{gprod}.\n\n Normally, once the rows belonging to each group are identified, the values\n corresponding to the group are gathered and the \\code{j}-expression is\n evaluated. This can be improved by computing the result directly without\n having to gather the values or evaluating the expression for each group\n (which can get costly with large number of groups) by implementing it\n specifically for a particular function. As a result, it is extremely fast.\n\n \\item In addition to all the functions above, \\code{.N} is also optimised to\n use GForce, when used separately or when combined with the functions mentioned\n above. Note further that GForce-optimized functions must be used separately,\n i.e., code like \\code{DT[ , max(x) - min(x), by=z]} will \\emph{not} currently\n be optimized to use \\code{gmax, gmin}.\n\n \\item Expressions of the form \\code{DT[i, j, by]} are also optimised when\n \\code{i} is a \\emph{subset} operation and \\code{j} is any/all of the functions\n discussed above.\n}\n\n---\n\n27. The default number of over-allocated spare column pointer slots has been increased from 64 to 1024. The wasted memory overhead (if never used) is insignificant (0.008 MB). The advantage is that adding a large number of columns by reference using := or set() inside a loop will not now saturate as quickly and need reallocating. An alleviation to issue [#1633](https://github.com/Rdatatable/data.table/issues/1633). See `?alloc.col` for how to change this default yourself. Accordingly, the warning 'attempt to reduce allocation has been ignored' has been downgraded to a message in verbose mode. That typically occurs when using (not recommended) `[<-` and `$<-` methods on data.table. The `n=` argument to `alloc.col()` is now simply the number of spare column slots to over-allocate (on creation and reallocation). An expression using `ncol(DT)` is still ok but now deprecated.\n\n 28. `?IDateTime` now makes clear that `wday`, `yday` and `month` are all 1- (not 0- as in `POSIXlt`) based, [#1658](https://github.com/Rdatatable/data.table/issues/1658); thanks @MichaelChirico.\n\n 29. Fixed misleading documentation of `?uniqueN`, [#1746](https://github.com/Rdatatable/data.table/issues/1746). Thanks @SymbolixAU.\n\n 30. `melt.data.table` restricts column names printed during warning messages to a maximum of five, [#1752](https://github.com/Rdatatable/data.table/issues/1752). Thanks @franknarf1.\n\n 31. data.table's `setNumericRounding` has a default value of 0, which means ordering, joining and grouping of numeric values will be done at *full precision* by default. Handles [#1642](https://github.com/Rdatatable/data.table/issues/1642), [#1728](https://github.com/Rdatatable/data.table/issues/1728), [#1463](https://github.com/Rdatatable/data.table/issues/1463), [#485](https://github.com/Rdatatable/data.table/issues/485).\n\n 32. Subsets with S4 objects in `i` are now faster, [#1438](https://github.com/Rdatatable/data.table/issues/1438). Thanks @DCEmilberg.\n\n 33. When formula RHS is `.` and multiple functions are provided to `fun.aggregate`, column names of the cast data.table columns don't have the `.` in them, as it doesn't add any useful information really, [#1821](https://github.com/Rdatatable/data.table/issues/1821). Thanks @franknarf1.\n\n 34. Function names are added to column names on cast data.tables only when more than one function is provided, [#1810](https://github.com/Rdatatable/data.table/issues/1810). Thanks @franknarf1.\n\n 35. The option `datatable.old.bywithoutby` to restore the old default has been removed. As warned 2 years ago in release notes and explicitly warned about for 1 year when used. Search down this file for the text 'bywithoutby' to see previous notes on this topic.\n\n 36. Using `with=FALSE` together with `:=` was deprecated in v1.9.4 released 2 years ago (Oct 2014). As warned then in release notes (see below) this is now a warning with advice to wrap the LHS of `:=` with parenthesis; e.g. `myCols=c(\"colA\",\"colB\"); DT[,(myCols):=1]`. In the next release, this warning message will be an error message.\n\n 37. Using `nomatch` together with `:=` now warns that it is ignored.\n\n 38. Logical `i` is no longer recycled. Instead an error message if it isn't either length 1 or `nrow(DT)`. This was hiding more bugs than was worth the rare convenience. The error message suggests to recycle explicitly; i.e. `DT[rep(,length=.N),...]`.\n\n 39. Thanks to Mark Landry and Michael Chirico for finding and reporting a problem in dev before release with auto `with=FALSE` (item 3 above) when `j` starts with with `!` or `-`, [#1864](https://github.com/Rdatatable/data.table/issues/1864). Fixed and tests added.\n\n---\n\n* Prettier printing of list columns. The first 6 items of atomic vectors\n are collapsed with \",\" followed by a trailing \",\" if there are more than\n 6, FR#1608. This difference to data.frame has been added to FAQ 2.17.\n Embedded objects (such as a data.table) print their class name only to avoid\n seemingly mangled output, bug #1803. Thanks to Yike Lu for reporting.\n For example:\n > data.table(x=letters[1:3],\n y=list( 1:10, letters[1:4], data.table(a=1:3,b=4:6) ))\n x y\n 1: a 1,2,3,4,5,6,\n 2: b a,b,c,d\n 3: c \n\n * Warnings added when joining character to factor, and factor to character.\n Character to character is now preferred in joins and needs no coercion.\n Even so, these coercions have been made much more efficient by taking\n a shallow copy of i internally, avoiding a full deep copy of i.\n\n * Ordered subsets now retain x's key. Always for logical and keyed i, using\n base::is.unsorted() for integer and unkeyed i. Implements FR#295.\n\n * mean() is now automatically optimized, #1231. This can speed up grouping\n by 20 times when there are a large number of groups. See wiki point 3, which\n is no longer needed to know. Turn off optimization by setting\n options(datatable.optimize=0).\n\n * DT[,lapply(.SD,...),by=...] is now automatically optimized, #2067. This can speed\n up applying a function by column by group, by over 20 times. See wiki point 5\n which is no longer needed to know. In other words:\n DT[,lapply(.SD,sum),by=grp]\n is now just as fast as :\n DT[,list(x=sum(x),y=sum(y)),by=grp]\n Don't forget to use .SDcols when a subset of columns is needed.\n\n * The package is now Byte Compiled (when installed in R 2.14.0 or later). Several\n internal speed improvements were made in this version too, such as avoiding\n internal copies. If you find 1.8.2 is faster, before attributing that to Byte\n Compilation, please install the package without Byte Compilation and compare\n ceteris paribus. If you find cases where speed has slowed, please let us know.\n\n * sapply(DT,class) gets a significant speed boost by avoiding a call to unclass()\n in as.list.data.table() called by lapply(DT,...), which copied the entire object.\n Thanks to a question by user1393348 on Stack Overflow, implementing #2000.\n https://stackoverflow.com/questions/10584993/r-loop-over-columns-in-data-table\n\n * The J() alias is now deprecated outside DT[...], but will still work inside\n DT[...], as in DT[J(...)].\n J() is conflicting with function J() in package XLConnect (#1747)\n and rJava (#2045). For data.table to change is easier, with some efficiency\n advantages too. The next version of data.table will issue a warning from J()\n when used outside DT[...]. The version after will remove it. Only then will\n the conflict with rJava and XLConnect be resolved.\n Please use data.table() directly instead of J(), outside DT[...].\n\n * New DT[.(...)] syntax (in the style of package plyr) is identical to\n DT[list(...)], DT[J(...)] and DT[data.table(...)]. We plan to add ..(), too, so\n that .() and ..() are analogous to the file system's ./ and ../; i.e., .()\n evaluates within the frame of DT and ..() in the parent scope.\n\n * New function rbindlist(l). This does the same as do.call(\"rbind\",l), but much\n faster.\n\n### BUG FIXES\n\n * DT[,f(.SD),by=colA] where f(x)=x[,colB:=1L] was a segfault, bug#1727.\n This is now a graceful error to say that using := in .SD's j is\n reserved for future use. This was already caught in most circumstances,\n other than via f(.SD). Thanks to Leon Baum for reporting. Test added.\n\n---\n\n\\name{rowwiseDT}\n\\alias{rowwiseDT}\n\\title{ Create a data.table row-wise }\n\\description{\n \\code{rowwiseDT} creates a \\code{data.table} object by specifying a row-by-row layout. This is convenient and highly readable for small tables.\n}\n\\usage{\nrowwiseDT(...)\n}\n\\arguments{\n \\item{...}{ Arguments that define the structure of a \\code{data.table}. The column names come from named arguments (like \\code{col=}), which must precede the data. See Examples. }\n}\n\\value{\nA \\code{data.table}. The default is for each column to return as a vector. However, if any entry has a length that is not one (e.g., \\code{list(1, 2)}), the whole column will be converted to a list column.\n}\n\\seealso{\n \\code{\\link{data.table}}\n}\n\\examples{\nrowwiseDT(\n A=,B=, C=,\n 1, \"a\",2:3,\n 2, \"b\",list(5)\n)\n}\n\n---\n\n3. When `j` contains no unquoted variable names (whether column names or not), `with=` is now automatically set to `FALSE`. Thus, `DT[,1]`, `DT[,\"someCol\"]`, `DT[,c(\"colA\",\"colB\")]` and `DT[,100:109]` now work as we all expect them to; i.e., returning columns, [#1188](https://github.com/Rdatatable/data.table/issues/1188), [#1149](https://github.com/Rdatatable/data.table/issues/1149). Since there are no variable names there is no ambiguity as to what was intended. `DT[,colName1:colName2]` no longer needs `with=FALSE` either since that is also unambiguous. That is a single call to the `:` function so `with=TRUE` could make no sense, despite the presence of unquoted variable names. These changes can be made since nobody can be using the existing behaviour of returning back the literal `j` value since that can never be useful. This provides a new ability and should not break any existing code. Selecting a single column still returns a 1-column data.table (not a vector, unlike `data.frame` by default) for type consistency for code (e.g. within `DT[...][...]` chains) that can sometimes select several columns and sometime one, as has always been the case in data.table. In future, `DT[,myCols]` (i.e. a single variable name) will look for `myCols` in calling scope without needing to set `with=FALSE` too, just as a single symbol appearing in `i` does already. The new behaviour can be turned on now by setting the tersely named option: `options(datatable.WhenJisSymbolThenCallingScope=TRUE)`. The default is currently `FALSE` to give you time to change your code. In this future state, one way (i.e. `DT[,theColName]`) to select the column as a vector rather than a 1-column data.table will no longer work leaving the two other ways that have always worked remaining (since data.table is still just a `list` after all): `DT[[\"someCol\"]]` and `DT$someCol`. Those base R methods are faster too (when iterated many times) by avoiding the small argument checking overhead inside the more flexible `DT[...]` syntax as has been highlighted in `example(data.table)` for many years. In the next release, `DT[,someCol]` will continue with old current behaviour but start to warn if the new option is not set. Then the default will change to TRUE to nudge you to move forward whilst still retaining a way for you to restore old behaviour for this feature only, whilst still allowing you to benefit from other new features of the latest release without changing your code. Then finally after an estimated 2 years from now, the option will be removed.\n\n### NEW FEATURES\n\n 1. `fwrite()` - parallel .csv writer:\n * Thanks to Otto Seiskari for the initial pull request [#580](https://github.com/Rdatatable/data.table/issues/580) that provided C code, R wrapper, manual page and extensive tests.\n * From there Matt parallelized and specialized C functions for writing integer/numeric exactly matching `write.csv` between 2.225074e-308 and 1.797693e+308 to 15 significant figures, dates (between 0000-03-01 and 9999-12-31), times down to microseconds in POSIXct, automatic quoting, `bit64::integer64`, `row.names` and `sep2` for `list` columns where each cell can itself be a vector. See [this blog post](https://blog.h2o.ai/2016/04/fast-csv-writing-for-r/) for implementation details and benchmarks.\n * Accepts any `list` of same length vectors; e.g. `data.frame` and `data.table`.\n * Caught in development before release to CRAN: thanks to Francesco Grossetti for [#1725](https://github.com/Rdatatable/data.table/issues/1725) (NA handling), Torsten Betz for [#1847](https://github.com/Rdatatable/data.table/issues/1847) (rounding of 9.999999999999998) and @ambils for [#1903](https://github.com/Rdatatable/data.table/issues/1903) (> 1 million columns).\n * `fwrite` status was tracked here: [#1664](https://github.com/Rdatatable/data.table/issues/1664)\n\n---\n\n\\name{setkey}\n\\alias{setkey}\n\\alias{setkeyv}\n\\alias{key}\n\\alias{haskey}\n\\alias{setindex}\n\\alias{setindexv}\n\\alias{indices}\n\\title{ Create key on a data.table }\n\\description{\n\\code{setkey} sorts a \\code{data.table} and marks it as sorted with an\nattribute \\code{\"sorted\"}. The sorted columns are the key. The key can be any\nnumber of columns. The data is always sorted in \\emph{ascending} order with \\code{NA}s\n(if any) always first. The table is changed \\emph{by reference} and there is\nno memory used for the key (other than marking which columns the data is sorted by).\n\nThere are three reasons \\code{setkey} is desirable:\n\\itemize{\n \\item binary search and joins are faster when they detect they can use an existing key\n \\item grouping by a leading subset of the key columns is faster because the groups are already gathered contiguously in RAM\n \\item simpler shorter syntax; e.g. \\code{DT[\"id\",]} finds the group \"id\" in the first column of \\code{DT}'s key using binary search. It may be helpful to think of a key as super-charged rownames: multi-column and multi-type.\n}\n\n\\code{NA}s are always first because:\n\\itemize{\n \\item \\code{NA} is internally \\code{INT_MIN} (a large negative number) in R. Keys and indexes are always in increasing order so if \\code{NA}s are first, no special treatment or branch is needed in many \\code{data.table} internals involving binary search. It is not optional to place \\code{NA}s last for speed, simplicity and robustness of internals at C level.\n \\item if any \\code{NA}s are present then we believe it is better to display them up front (rather than hiding them at the end) to reduce the risk of not realizing \\code{NA}s are present.\n}\n\nIn \\code{data.table} parlance, all \\code{set*} functions change their input\n\\emph{by reference}. That is, no copy is made at all other than for temporary\nworking memory, which is as large as one column. The only other \\code{data.table}\noperator that modifies input by reference is \\code{\\link{:=}}. Check out the\n\\code{See Also} section below for other \\code{set*} functions \\code{data.table}\nprovides.\n\n\\code{setindex} creates an index for the provided columns. This index is simply an\nordering vector of the dataset's rows according to the provided columns. This order vector\nis stored as an attribute of the \\code{data.table} and the dataset retains the original order\nof rows in memory. See the \\href{../doc/datatable-secondary-indices-and-auto-indexing.html}{\\code{vignette(\"datatable-secondary-indices-and-auto-indexing\")}} for more details.\n\n\\code{key} returns the \\code{data.table}'s key if it exists; \\code{NULL} if none exists.\n\n---\n\n* := now works with a logical i subset; e.g.,\n DT[x==1,y:=x]\n Thanks to Muhammad Waliji for reporting.\n\n### USER VISIBLE CHANGES\n\n * Error message \"column of i is not internally type integer\"\n is now more helpful adding \"i doesn't need to be keyed, just\n convert the (likely) character column to factor\". Thanks to\n Christoph_J for his SO question.\n\n\n## data.table v1.7.0\n\n### NEW FEATURES\n\n * data.table() now accepts list columns directly rather than\n needing to add list columns to an existing data.table; e.g.,\n\n DT = data.table(x=1:3,y=list(4:6,3.14,matrix(1:12,3)))\n\n Thanks to Branson Owen for reminding. As before, list columns\n can be created via grouping; e.g.,\n\n DT = data.table(x=c(1,1,2,2,2,3,3),y=1:7)\n DT2 = DT[,list(list(unique(y))),by=x]\n DT2\n x V1\n [1,] 1 1, 2\n [2,] 2 3, 4, 5\n [3,] 3 6, 7\n\n and list columns can be grouped; e.g.,\n\n DT2[,sum(unlist(V1)),by=list(x%%2)]\n x V1\n [1,] 1 16\n [2,] 0 12\n\n Accordingly, one item has been added to FAQ 2.17 (differences\n between data.frame and data.table): data.frame(list(1:2,\"k\",1:4))\n creates 3 columns, data.table creates one list column.\n\n * subset, transform and within now retain keys when the expression\n does not 'touch' key columns, implementing FR #1341.\n\n * Recycling list() items on RHS of := now works; e.g.,\n\n DT[,1:4:=list(1L,NULL),with=FALSE]\n # set columns 1 and 3 to 1L and remove columns 2 and 4\n\n * Factor columns on LHS of :=, [<- and $<- can now be assigned\n new levels; e.g.,\n\n DT = data.table(A=c(\"a\",\"b\"))\n DT[2,\"A\"] <- \"c\" # adds new level automatically\n DT[2,A:=\"c\"] # same (faster)\n DT$A = \"newlevel\" # adds new level and recycles it\n\n Thanks to Damian Betebenner and Chris Neff for highlighting.\n To change the type of a column, provide a full length RHS (i.e.\n 'replace' the column).\n\n### BUG FIXES\n\n * := with i all FALSE no longer sets the whole column, fixing\n bug #1570. Thanks to Chris Neff for reporting.\n\n * 0 length by (such as NULL and character(0)) now behave as\n if by is missing, fixing bug #1599. This is useful when by\n is dynamic and a 'dont group' needs to be represented.\n Thanks to Chris Neff for reporting.\n\n * NULL j no longer results in 'inconsistent types' error, but\n instead returns no rows for that group, fixing bug #1576.\n\n * matrix i is now an error rather than using i as if it were a\n vector and obtaining incorrect results. It was undocumented that\n matrix might have been an acceptable type. matrix i is\n still acceptable in [<-; e.g.,\n DT[is.na(DT)] <- 1L\n and this now works rather than assigning to non-NA items in some\n cases.\n\n * Inconsistent [<- behaviour is now fixed (#1593) so these examples\n now work :\n DT[x == \"a\", ]$y <- 0L\n DT[\"a\", ]$y <- 0L\n But, := is highly encouraged instead for speed; i.e.,\n DT[x == \"a\", y:=0L]\n DT[\"a\", y:=0L]\n Thanks to Leon Baum for reporting.\n\n * unique on an unsorted table now works, fixing bug #1601.\n Thanks to a question by Iterator on Stack Overflow.\n\n * Bug fix #1534 in v1.6.5 (see NEWS below) only worked if data.table\n was higher than IRanges on the search() path, despite the item in\n NEWS stating otherwise. Fixed.\n\n * Compatibility with package sqldf (which can call do.call(\"rbind\",...)\n on an empty \"...\") is fixed and test added. data.table was switching\n on list(...)[[1]] rather than ..1. Thanks to RYogi for reporting #1623.\n\n### USER VISIBLE CHANGES\n\n---\n\n#: assign.c:457\nmsgid \"\"\n\"It appears that at some earlier point, names of this data.table have been \"\n\"reassigned. Please ensure to use setnames() rather than names<- or \"\n\"colnames<-. Otherwise, please report to data.table issue tracker.\"\nmsgstr \"\"\n\"Parece que em algum momento anterior, os nomes desta data.table foram \"\n\"reatribuídos. Certifique-se de usar setnames() em vez de names<- ou \"\n\"colnames<-. Caso contrário, por favor, relate isso no rastreador de \"\n\"problemas do data.table.\"\n\n#: assign.c:464\nmsgid \"\"\n\"It appears that at some earlier point, attributes of this data.table have \"\n\"been reassigned. Please use setattr(DT, name, value) rather than attr(DT, \"\n\"name) <- value. If that doesn't apply to you, please report your case to the \"\n\"data.table issue tracker.\"\nmsgstr \"\"\n\"Parece que em algum momento anterior, atributos desta data.table foram \"\n\"reatribuídos. Favor usar setattr(DT, nome, valor) em vez de attr(DT, nome) \"\n\"<- valor. Se isso não se aplicar ao seu caso, por favor, relate isso no \"\n\"rastreador de problemas do data.table.\"\n\n#: assign.c:496\n#, c-format\nmsgid \"\"\n\"RHS for item %d has been duplicated because MAYBE_REFERENCED==%d \"\n\"MAYBE_SHARED==%d ALTREP==%d, but then is being plonked. length(values)==%d; \"\n\"length(cols)==%d\\n\"\nmsgstr \"\"\n\"O lado direito (RHS) para o item %d foi duplicado porque \"\n\"MAYBE_REFERENCED==%d MAYBE_SHARED==%d ALTREP==%d, mas depois está sendo \"\n\"plonked. length(values)==%d; length(cols)==%d\\n\"\n\n#: assign.c:501\n#, c-format\nmsgid \"\"\n\"Direct plonk of unnamed RHS, no copy. MAYBE_REFERENCED==%d, \"\n\"MAYBE_SHARED==%d\\n\"\nmsgstr \"\"\n\"Plonk direto de lado direito (RHS) sem nome, sem cópia. \"\n\"MAYBE_REFERENCED==%d, MAYBE_SHARED==%d\\n\"\n\n#: assign.c:570\n#, c-format\nmsgid \"\"\n\"Dropping index '%s' as it doesn't have '__' at the beginning of its name. It \"\n\"was very likely created by v1.9.4 of data.table.\\n\"\nmsgstr \"\"\n\"Descartando o índice '%s' porque ele não tem '__' no início do nome. Muito \"\n\"provavelmente foi criado pela versão 1.9.4 do data.table.\\n\"\n\n#: assign.c:615 assign.c:631\n#, c-format\nmsgid \"Dropping index '%s' due to an update on a key column\\n\"\nmsgstr \"\"\n\"Descartando o índice '%s' devido a uma atualização em uma coluna-chave\\n\"\n\n#: assign.c:624\n#, c-format\nmsgid \"Shortening index '%s' to '%s' due to an update on a key column\\n\"\nmsgstr \"\"\n\"Reduzindo o índice '%s' para '%s' devido a uma atualização em uma coluna-\"\n\"chave\\n\"\n\n#: assign.c:682\n#, c-format\nmsgid \"(column %d named '%s')\"\nmsgstr \"(coluna %d de nome '%s')\"\n\n#: assign.c:716\n#, c-format\nmsgid \"\"\n\"Cannot assign 'factor' to '%s'. Factors can only be assigned to factor, \"\n\"character or list columns.\"\nmsgstr \"\"\n\"Não é possível atribuir 'factor' a '%s'. Os fatores só podem ser atribuídos \"\n\"a colunas de fator, caractere ou lista.\"\n\n#: assign.c:731\n#, c-format\nmsgid \"\"\n\"Assigning factor numbers to target vector. But %d is outside the level range \"\n\"[1,%d]\"\nmsgstr \"\"\n\"Atribuindo números de fator ao vetor alvo. Mas %d está fora do intervalo de \"\n\"níveis [1,%d]\"\n\n#: assign.c:733\n#, c-format\nmsgid \"\"\n\"Assigning factor numbers to column %d named '%s'. But %d is outside the \"\n\"level range [1,%d]\"\nmsgstr \"\"\n\"Atribuindo números de fator à coluna %d de nome '%s'. Mas %d está fora do \"\n\"intervalo de níveis [1,%d]\"\n\n#: assign.c:743\n#, c-format\nmsgid \"\"\n\"Assigning factor numbers to target vector. But %f is outside the level range \"\n\"[1,%d], or is not a whole number.\"\nmsgstr \"\"\n\"Atribuindo números de fator ao vetor alvo. Mas %f está fora do intervalo de \"\n\"níveis [1,%d] ou não é um número inteiro.\"\n\n#: assign.c:745\n#, c-format\nmsgid \"\"\n\"Assigning factor numbers to column %d named '%s'. But %f is outside the \"\n\"level range [1,%d], or is not a whole number.\"\nmsgstr \"\"\n\"Atribuindo números de fator à coluna %d de nome '%s'. Mas %f está fora do \"\n\"intervalo de níveis [1,%d], ou não é um número inteiro.\"\n\n---\n\n## He observado que `base::cbind.data.frame` (y `base::rbind.data.frame`) parecen ser modificados por data.table. ¿Cómo es posible? ¿Por qué?\n\nEra una solución temporal de último recurso antes de que se corrigiera la resolución de métodos S3 de rbind y cbind en R >= 4.0.0. En esencia, el problema residía en que `data.table` hereda de `data.frame`, *y* `base::cbind` y `base::rbind` (de forma única) realizan su propia resolución S3 internamente, como se documenta en `?cbind`. La solución alternativa para `data.table` consistía en añadir un bucle `for` al inicio de cada función directamente en `base`. Esta modificación se realizaba dinámicamente; es decir, se obtuvo la definición `base` de `cbind.data.frame`, se añadía el bucle `for` al inicio y luego se volvía a asignar a `base`. Esta solución se diseñó para ser robusta ante varias definiciones de `base::cbind.data.frame` en diferentes versiones de R, incluyendo cambios futuros desconocidos. Funcionó correctamente. Los requisitos en conflicto eran:\n\n - `cbind(DT, DF)` debe funcionar. La definición de `cbind.data.table` no funcionaba porque `base::cbind` realizaba su propia resolución S3 y requería (antes de R 4.0.0) que el *primer* método `cbind` para cada objeto que se le pasa fuera *idéntico*. Esto no se cumple en `cbind(DT, DF)`, ya que el primer método para `DT` es `cbind.data.table`, pero el primer método para `DF` es `cbind.data.frame`. `base::cbind` entonces fallaba en su código interno `bind`, que parece tratar `DT` como una `lista` normal y devuelve una salida `matrix` de aspecto extraño e inutilizable. Véase [a continuación](#cbinderror). No podemos simplemente aconsejar a los usuarios que no llamen a `cbind(DT, DF)` porque paquetes como `ggplot2` hacen dicha llamada ([prueba 167.2](https://github.com/Rdatatable/data.table/blob/master/inst/tests/tests.Rraw#L444-L447)).\n\n - Esto, naturalmente, llevó a intentar enmascarar `cbind.data.frame`. Dado que un data.table es un `data.frame`, `cbind` encontraría el mismo método para `DT` y `DF`. Sin embargo, esto tampoco funcionó porque `base::cbind` parece encontrar primero los métodos en `base`; *es decir*, `base::cbind.data.frame` no es enmascarable.\n\n - Finalmente, intentamos enmascarar `cbind` (v1.6.5 y v1.6.6). Esto permitió que `cbind(DT, DF)` funcionara, pero introdujo problemas de compatibilidad con el paquete `IRanges`, ya que `IRanges` también enmascara `cbind`. Funcionaba si `IRanges` estaba en una posición inferior a data.table en la ruta `search()`, pero si `IRanges` estaba en una posición superior a data.table, `cbind` nunca se llamaría y la salida de `matrix`, de aspecto extraño, volvía a aparecer (ver [abajo](#cbinderror)).\n\nMuchas gracias al equipo central de R por solucionar el problema en septiembre de 2019. data.table v1.12.6+ ya no aplica la solución alternativa en R >= 4.0.0.\n\n## He leído sobre la resolución de métodos (p. ej., \"merge\" puede o no derivar a \"merge.data.table\"), pero ¿cómo sabe R cómo derivar? ¿Son los puntos significativos o especiales? ¿Cómo sabe R a qué función resolver y cuándo? {#r-dispatch}\n\n---\n\n\\item{optimize}{ A vector of different optimization levels to test. The code in \\code{x} will be run once for each optimization level, with \\code{options(datatable.optimize=optimize)} set accordingly. All optimization levels must pass the test for the overall test to pass. If no \\code{y} is supplied, the results from the different levels are compared to each other for equality. If a \\code{y} is supplied, the results from each level are compared to \\code{y}. }\n}\n\\note{\n \\code{NA_real_} and \\code{NaN} are treated as equal, use \\code{identical} if distinction is needed. See examples below.\n\n---\n\n#: data.table.R:139\n#, c-format\nmsgid \"Item '%s' not found in names of input list\"\nmsgstr \"Не могу найти «%s» среди имён входного списка\"\n\n#: data.table.R:159\n#, c-format\nmsgid \"\"\n\"[ was called on a data.table in an environment that is not data.table-aware \"\n\"(i.e. cedta()), but '%s' was used, implying the owner of this call really \"\n\"intended for data.table methods to be called. See vignette('datatable-\"\n\"importing') for details on properly importing data.table.\"\nmsgstr \"\"\n\"Метод [ был вызван для data.table из окружения, не поддерживающего data.\"\n\"table (см. ?cedta()), но было передано '%s', что означает, что вызывающей \"\n\"функции действительно нужен метод data.table. Подробнее о правильном \"\n\"использовании data.table в пакетах см. в vignette('datatable-importing').\"\n\n#: data.table.R:170\n#, c-format\nmsgid \"verbose must be logical or integer\"\nmsgstr \"«verbose» должно быть логическим или целочисленным\"\n\n#: data.table.R:171\n#, c-format\nmsgid \"verbose must be length 1 non-NA\"\nmsgstr \"«verbose» должно быть длины 1 и не-NA\"\n\n#: data.table.R:179\n#, c-format\nmsgid \"Ignoring by/keyby because 'j' is not supplied\"\nmsgstr \"Игнорирую «by»/«keyby», потому что «j» не был передан\"\n\n#: data.table.R:193\n#, c-format\nmsgid \"When by and keyby are both provided, keyby must be TRUE or FALSE\"\nmsgstr \"Когда «by» и «keyby» оба переданы, «keyby» должно быть TRUE либо FALSE\"\n\n#: data.table.R:196 data.table.R:261 data.table.R:351\nmsgid \"Argument '%s' after substitute: %s\"\nmsgstr \"Аргумент «%s» после подстановки: %s\"\n\n#: data.table.R:205\n#, c-format\nmsgid \"\"\n\"When on= is provided but not i=, on= must be a named list or data.table|\"\n\"frame, and a natural join (i.e. join on common names) is invoked. Ignoring \"\n\"on= which is '%s'.\"\nmsgstr \"\"\n\"Если указано on=, но не i=, on= должно быть именованным списком или data.\"\n\"table|frame; тогда будет выполнено натуральное соединение (т. е. по столбцам \"\n\"с общими именами). Игнорирую on=, которое имеет значение '%s'.\"\n\n#: data.table.R:218\n#, c-format\nmsgid \"\"\n\"i and j are both missing so ignoring the other arguments. This warning will \"\n\"be upgraded to error in future.\"\nmsgstr \"\"\n\"i и j отсутствуют, поэтому игнорирую остальные аргументы. В будущем это \"\n\"предупреждение будет преобразовано в ошибку.\"\n\n#: data.table.R:222\n#, c-format\nmsgid \"mult argument can only be 'first', 'last', 'all' or 'error'\"\nmsgstr \"аргумент «mult» должен быть 'first', 'last', 'all' или 'error'\"\n\n#: data.table.R:224\n#, c-format\nmsgid \"\"\n\"roll must be a single TRUE, FALSE, positive/negative integer/double \"\n\"including +Inf and -Inf or 'nearest'\"\nmsgstr \"\"\n\"roll должен быть TRUE, FALSE, положительным/отрицательным числом, включая \"\n\"+Inf и -Inf, либо 'nearest'\"\n\n#: data.table.R:226\n#, c-format\nmsgid \"roll is '%s' (type character). Only valid character value is 'nearest'.\"\nmsgstr \"\"\n\"«roll» - это '%s' (строка). Единственное допустимое строковое значение - \"\n\"'nearest'.\"\n\n#: data.table.R:231\n#, c-format\nmsgid \"rollends must be a logical vector\"\nmsgstr \"«rollends» должно быть логическим вектором\"\n\n#: data.table.R:232\n#, c-format\nmsgid \"rollends must be length 1 or 2\"\nmsgstr \"«rollends» должно быть длины 1 или 2\"\n\n#: data.table.R:240\n#, c-format\nmsgid \"\"\n\"nomatch= must be either NA or NULL (or 0 for backwards compatibility which \"\n\"is the same as NULL but please use NULL)\"\nmsgstr \"\"\n\"nomatch= должно быть либо NA, либо NULL (ранее 0 значило то же, что сейчас \"\n\"значит NULL)\"\n\n#: data.table.R:243\n#, c-format\nmsgid \"which= must be a logical vector length 1. Either FALSE, TRUE or NA.\"\nmsgstr \"which= должен быть FALSE, TRUE или NA_logical_.\"\n\n#: data.table.R:244\n#, c-format\nmsgid \"\"\n\"which==%s (meaning return row numbers) but j is also supplied. Either you \"\n\"need row numbers or the result of j, but only one type of result can be \"\n\"returned.\"\nmsgstr \"\"\n\"which==%s (значит, вернуть номера строк), но также передан j. Вы можете \"\n\"запросить либо одно, либо другое, но не всё сразу.\"\n\n---\n\n\\name{data.table-package}\n\\alias{data.table-package}\n\\docType{package}\n\\alias{data.table}\n\\alias{Ops.data.table}\n\\alias{is.na.data.table}\n\\alias{[.data.table}\n\\alias{.}\n\\alias{.(}\n\\alias{.()}\n\\alias{..}\n\\title{ Enhanced data.frame }\n\\description{\n \\code{data.table} \\emph{inherits} from \\code{data.frame}. It offers fast and memory efficient: file reader and writer, aggregations, updates, equi, non-equi, rolling, range and interval joins, in a short and flexible syntax, for faster development.\n\n It is inspired by \\code{A[B]} syntax in \\R where \\code{A} is a matrix and \\code{B} is a 2-column matrix. Since a \\code{data.table} \\emph{is} a \\code{data.frame}, it is compatible with \\R functions and packages that accept \\emph{only} \\code{data.frame}s.\n\n Type \\code{vignette(package=\"data.table\")} to get started. The \\href{../doc/datatable-intro.html}{Introduction to data.table} vignette introduces \\code{data.table}'s \\code{x[i, j, by]} syntax and is a good place to start. If you have read the vignettes and the help page below, please read the \\href{https://github.com/Rdatatable/data.table/wiki/Support}{data.table support guide}.\n\n Please check the \\href{https://github.com/Rdatatable/data.table/wiki}{homepage} for up to the minute live NEWS.\n\n Tip: one of the \\emph{quickest} ways to learn the features is to type \\code{example(data.table)} and study the output at the prompt.\n}\n\\usage{\ndata.table(\\dots, keep.rownames=FALSE, check.names=FALSE, key=NULL, stringsAsFactors=FALSE)\n\n\\method{[}{data.table}(x, i, j, by, keyby, with = TRUE,\n nomatch = NA,\n mult = \"all\",\n roll = FALSE,\n rollends = if (roll==\"nearest\") c(TRUE,TRUE)\n else if (roll>=0) c(FALSE,TRUE)\n else c(TRUE,FALSE),\n which = FALSE,\n .SDcols,\n verbose = getOption(\"datatable.verbose\"), # default: FALSE\n allow.cartesian = getOption(\"datatable.allow.cartesian\"), # default: FALSE\n drop = NULL, on = NULL, env = NULL, \n showProgress = getOption(\"datatable.showProgress\", interactive()))\n}\n\\arguments{\n \\item{\\dots}{ Just as \\code{\\dots} in \\code{\\link{data.frame}}. Usual recycling rules are applied to vectors of different lengths to create a list of equal length vectors.}\n\n \\item{keep.rownames}{ If \\code{\\dots} is a \\code{matrix} or \\code{data.frame}, \\code{TRUE} will retain the rownames of that object in a column named \\code{rn}.}\n\n \\item{check.names}{ Just as \\code{check.names} in \\code{\\link{data.frame}}.}\n\n \\item{key}{ Character vector of one or more column names which is passed to \\code{\\link{setkey}}.}\n\n \\item{stringsAsFactors}{Logical (default is \\code{FALSE}). Convert all \\code{character} columns to \\code{factor}s?}\n\n \\item{x}{ A \\code{data.table}.}\n\n \\item{i}{ Integer, logical or character vector, single column numeric \\code{matrix}, expression of column names, \\code{list}, \\code{data.frame} or \\code{data.table}.\n\n \\code{integer} and \\code{logical} vectors work the same way they do in \\code{\\link{[.data.frame}} except logical \\code{NA}s are treated as FALSE.\n\n \\code{expression} is evaluated within the frame of the \\code{data.table} (i.e. it sees column names as if they are variables) and can evaluate to any of the other types.\n\n \\code{character}, \\code{list} and \\code{data.frame} input to \\code{i} is converted into a \\code{data.table} internally using \\code{\\link{as.data.table}}.\n\n If \\code{i} is a \\code{data.table}, the columns in \\code{i} to be matched against \\code{x} can be specified using one of these ways:\n\n \\itemize{\n \\item \\code{on} argument (see below). It allows for both \\code{equi-} and the newly implemented \\code{non-equi} joins.\n\n \\item If not, \\code{x} \\emph{must be keyed}. Key can be set using \\code{\\link{setkey}}. If \\code{i} is also keyed, then first \\emph{key} column of \\code{i} is matched against first \\emph{key} column of \\code{x}, second against second, etc..\n\n---\n\n# related to !is.integer(verbose)\ntest(99.1, data.table(a=1,b=2)[1,1, verbose=1], error=\"verbose must be logical or integer\")\ntest(99.2, data.table(a=1,b=2)[1,1, verbose=1:2], error=\"verbose must be length 1 non-NA\")\ntest(99.3, data.table(a=1,b=2)[1,1, verbose=NA], error=\"verbose must be length 1 non-NA\")\ntest(99.4, options=c(datatable.verbose=1), coerceAs(1, 2L), error=\"verbose option must be length 1 non-NA logical or integer\")\n\n---\n\n```{r}\nkey(flights)\nflights[.(\"LGA\", \"TPA\"), .(arr_delay)]\n```\n\n* Los *índices de fila* correspondientes a `origin == \"LGA\"` y `dest == \"TPA\"` se obtienen utilizando un *filtro basado en clave*.\n\n* Una vez que tenemos los índices de fila, revisamos `j`, que solo requiere la columna `arr_delay`. Así que simplemente seleccionamos la columna `arr_delay` para esos *índices de fila* de la misma manera que vimos en la viñeta [`vignette(\"datatable-intro\", package=\"data.table\")`](datatable-intro.html).\n\n* Podríamos haber devuelto el resultado usando `with = FALSE` también.\n\n ```r\n flights[.(\"LGA\", \"TPA\"), \"arr_delay\", with = FALSE]\n ```\n\n### b) Encadenamiento\n\n#### -- Con el resultado obtenido anteriormente, utilizar encadenamiento para ordenar la columna en orden decreciente\n\n```{r}\nflights[.(\"LGA\", \"TPA\"), .(arr_delay)][order(-arr_delay)]\n```\n\n### c) Calcular o *hacer* en `j`\n\n#### -- Encontrar el retraso máximo de llegada correspondiente a `origin = \"LGA\"` y `dest = \"TPA\"`.\n\n```{r}\nflights[.(\"LGA\", \"TPA\"), max(arr_delay)]\n```\n\n*Podemos verificar que el resultado es idéntico al primer valor (486) del ejemplo anterior.\n\n### d) *sub-asignar* por referencia usando `:=` en `j`\n\nYa vimos este ejemplo en la viñeta [`vignette(\"datatable-reference-semantics\", package=\"data.table\")`](datatable-reference-semantics.html). Veamos todas las `horas` disponibles en la *data.table* `flights`:\n\n```{r}\n# get all 'hours' in flights\nflights[, sort(unique(hour))]\n```\n\nObservamos que hay un total de 25 valores únicos en los datos. Parece que hay tanto *0* como *24* horas. Reemplacemos *24* por *0*, pero esta vez usando *key*.\n\n```{r}\nsetkey(flights, hour)\nkey(flights)\nflights[.(24), hour := 0L]\nkey(flights)\n```\n\n* Primero configuramos `key` como `hour`. Esto reordena los `flights` según la columna `hour` y marca esa columna como `key`.\n\n* Ahora podemos filtrar en `hour` usando la notación `.()`. Filtramos para el valor *24* y obtenemos los *índices de fila* correspondientes.\n\n* Y en esos índices de fila, reemplazamos la columna `key` con el valor `0`.\n\n* Dado que reemplazamos los valores en la columna *key*, la tabla de datos `flights` ya no se ordena por `hour`. Por lo tanto, la clave se ha eliminado automáticamente al establecerla en NULL.\n\nAhora, no debería haber ningún *24* en la columna \"hora\".\n\n```{r}\nflights[, sort(unique(hour))]\n```\n\n### e) Agregación utilizando `by`\n\nPrimero, establezcamos nuevamente la clave en `origin, dest`.\n\n```{r}\nsetkey(flights, origin, dest)\nkey(flights)\n```\n\n#### Obtener el retraso máximo de salida para cada mes correspondiente a `origin = \"JFK\"`. Ordenar el resultado por mes.\n\n```{r}\nans <- flights[\"JFK\", max(dep_delay), keyby = month]\nhead(ans)\nkey(ans)\n```\n\n* Filtramos en la columna `clave` *origen* para obtener los *índices de fila* correspondientes a *\"JFK\"*.\n\n* Una vez que obtenemos los índices de fila, solo necesitamos dos columnas: `month` para agrupar y `dep_delay` para obtener `max()` para cada grupo. Por lo tanto, la optimización de consulta de *data.table* filtra solo aquellas dos columnas correspondientes a los *índices de fila* obtenidos en `i`, para mayor velocidad y eficiencia de memoria.\n\n* Y en ese filtro, agrupamos por *mes* y calculamos `max(dep_delay)`.\n\n* Usamos `keyby` para clasificar automáticamente ese resultado por *mes*. Ahora entendemos lo que significa. Además de ordenar, también establece *mes* como la columna `key`.\n\n## 3. Argumentos adicionales: `mult` y `nomatch`\n\n### a) El argumento *mult*\n\nPodemos elegir, para cada consulta, si se deben devolver *todas* (\"all\") las filas coincidentes, o solo la *primera* (\"first\") o la *última* (\"last\") mediante el argumento `mult`. El valor predeterminado es *\"all\"*, el que hemos visto hasta ahora.\n\n#### -- Obtener solo la primera fila coincidente de todas las filas donde `origin` coincide con *\"JFK\"* y `dest` coincide con *\"MIA\"*\n\n```{r}\nflights[.(\"JFK\", \"MIA\"), mult = \"first\"]\n```\n\n---\n\nLink Title Author 2025.09 Manipuler des données avec data.table Pierre-Yves Berrard, Lino Galiana et Olivier Meslin 2025.05 Syntax conversion: data.table vs. base vs. dplyr Vincent Arel-Bundock 2024.11 Data wrangling with data.table Stata2R: Kyle Butts , Nick Huntington-Klein , and Grant McDermott 2024.11 Julia DataFrames.jl comparison with data.table authors of DataFrames.jl docs 2024.11 data.table.threads Anirban Chetia 2024.10 Comparing data.table reshape to duckdb and polars Toby Dylan Hocking 2024.10 Benchmarking rolling window functions in R Mikkel Roald-Arbøl 2024.09 Mutation testing for data.table Anirban Chetia 2024.08 Collapse reshape benchmark Toby Dylan Hocking 2024.07 Benchmarking a change in data.table Toby Dylan Hocking 2024.06 data.table for the Google Summer of Code 2024 (Joshua Wu) Joshua Wu 2024.02 Column assignment and reference semantics in data.table Toby Dylan Hocking 2024.02 NSF project activities Anirban Chetia 2024.02 new programming with data.table John MacKintosh 2024.02 more .I in data.table John MacKintosh 2024.01 .I in data.table John MacKintosh 2024.01 Reshape performance comparison Toby Dylan Hocking 2023.12 Comparing data table to frame for row subset Toby Dylan Hocking 2023.12 non-equi joins in data.table John MacKintosh 2023.11 Some pedagogical elements of computer programming for data science: A comparison of three approaches to teaching the R language David Shilane , Nicole Di Crecchio , Nicole L. Lorenzetti 2023.11 data.table CRAN diffs: Verifying consistency between CRAN and github Toby Dylan Hocking 2023.10 data.table asymptotic timings Toby Dylan Hocking 2023.03 A Coding Translation to Increase the Efficiency of Programmatic Data Analyses David Shilane 2023.02 Pivoting data in R with tidyr and data.table John MacKintosh 2022.11 dplyr 1.1.0 is coming soon Davis Vaughan 2022.11 Handling larger than memory data with {arrow} and {duckdb} David Lucey 2022.11 R Package Release History: Extracting and plotting data from CRAN web site Toby Dylan Hocking 2022.10 Efficiency comparison of dplyr and tidyr functions vs base R Manuel Teodoro Tenango 2022.08 modifying columns in datatable with lapply John MacKintosh 2022.08 Simulating data from a non-linear function by specifying a handful of points Keith Goldfeld 2022.06 Timing data.table Operations Thomas Shafer 2022.06 Shuffling Columns With data.table Thomas Shafer 2022.06 A quirk when using data.table? Kenneth Tay 2022.05 Comparing performances of CSV to RDS, Parquet, and Feather file formats in R Tomaž Kaštrun 2022.04 Loading a large, messy csv using data.table fread with cli tools David Lucey 2022.04 Greatly revised edition of tidyverse skeptic Original 2019.07 below: Ctrl-F \"matloff\" Norm Matloff 2022.03 Shiny: Fast Data Loading with fst Philipp Probst 2021.12 Optimising dplyr Tom Jemmett 2021.11 Should I Move to a Database? Roel M. Hogervorst 2021.10 Most Starred and Forked GitHub Repos for Data Science and R Kenneth Leung 2021.10 fwf without the faff John MacKintosh 2021.10 Simulating the Squid Game bridge scene in R John Paul Helveston 2021.09 Calculating hotel occupancy with R John MacKintosh 2021.08 Exploring Stock Market Listing Mortality since 1986 David Lucey 2021.08 Introducing the fastverse: An Extensible Suite of High-Performance and Low-Dependency Packages for Statistical Computing and Data Manipulation Sebastian Krantz 2021.08 Well Well Well My Excel John MacKintosh 2021.08 Cutting down code in dplyr and data.table John MacKintosh 2021.08 Code performance in R: Working with large datasets Mira Céline Klein 2021.07 Time Travel with py datatable 1.0 Gregory Kanevsky 2021.06 DTPlyr – easier data.table for DPLYR users Gary Hutson 2021.06 Stress testing reshape operations on list columns Toby Dylan Hocking 2021.06 Wide-to-tall Data Reshaping Using Regular Expressions and the nc Package Toby Dylan Hocking 2021.05 Update about data reshaping and visualization in R and python Toby Dylan Hocking 2021.05 Hamburg RUG: A professional trading\n\n---\n\nВ этом случае неэкспортированная функция `[.data.table` превратится в вызов\n`[.data.frame` в качестве меры предосторожности, поскольку `data.table` не\nимеет возможности узнать, что родительский пакет осведомлен о том, что он\nпытается выполнить вызов синтаксиса API запросов `data.table` (что может\nпривести к неожиданному поведению, поскольку структура вызовов\n`[.data.frame` и `[.data.table` принципиально отличается: например,\nпоследний имеет гораздо больше аргументов).\n\nЕсли Вы предпочитаете такой подход к разработке пакетов, задайте переменную\n`.datatable.aware = TRUE` в любом месте исходного кода R (экспортировать её\nне нужно). Это сообщит `data.table`, что Вы, как разработчик пакета,\nспроектировали свой код так, чтобы намеренно полагаться на функциональность\n`data.table`, даже если это может быть не очевидно при просмотре вашего\nфайла `NAMESPACE`.\n\n`data.table` на лету определяет, знает ли вызывающая функция, что она\nобращается к `data.table`, с помощью внутренней функции `cedta`\n(«**C**alling **E**nvironment is **D**ata **T**able **A**ware», окружение\nвызова функции знает про `data.table`), которая, помимо проверки\n`?getNamespaceImports` для вашего пакета, также проверяет существование этой\nпеременной (и некоторые другие вещи).\n\n## Дополнительная информация о зависимостях\n\nБолее официальную документацию о зависимостях пакетов и способах их\nобъявления можно найти в официальном руководстве: [Writing R\nExtensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html).\n\n## Импорт функций на C из data.table\n\nНекоторые из внутренне используемых подпрограмм на C теперь экспортированы\nдля другого кода на C и могут быть использованы в пакетах R непосредственно\nиз кода на C. Подробнее о том, как это делать, см. в\n[`?cdt`](https://rdatatable.gitlab.io/data.table/reference/cdt.html) и в\nразделе [Writing R\nExtensions](https://cran.r-project.org/doc/manuals/r-release/R-exts.html)\n_Linking to native routines in other packages_.\n\n## Импорт извне R {#non-r-api}\n\nНекоторые небольшие части Си-кода `data.table` были изолированы от R C API и\nтеперь могут быть использованы из приложений, не относящихся к R, путем\nкомпоновки с файлами .so / .dll. Более подробная информация об этом будет\nпредоставлена позже, а пока вы можете изучить Си-код, который был изолирован\nот R C API в\n[src/fread.c](https://github.com/Rdatatable/data.table/blob/master/src/fread.c)\nи\n[src/fwrite.c](https://github.com/Rdatatable/data.table/blob/master/src/fwrite.c).\n\n## Как преобразовать зависимость от data.table из Depends в Imports\n\nЧтобы преобразовать зависимость Вашего пакета от `data.table` типа `Depends`\nв зависимость типа `Imports`, выполните следующие действия:\n\n### Шаг 0. Убедитесь, что ваш пакет изначально проходит R CMD check\n\n### Шаг 1. Обновите файл DESCRIPTION, переместив data.table из Depends в Imports\n\n**До:**\n```dcf\nDepends:\n R (>= 3.5.0),\n data.table\nImports:\n```\n\n**После:**\n```dcf\nDepends:\n R (>= 3.5.0)\nImports:\n data.table\n```\n\n### Шаг 2.1: Выполните команду `R CMD check`\n\nЗапустите `R CMD check`, чтобы выявить недостающие импорты. Этот шаг:\n\n- Автоматически обнаруживает любые функции или символов из `data.table`,\n которые не были импортированы явно.\n- Отмечает отсутствующие специальные символы, такие как `.N`, `.SD` и `:=`.\n- Сразу же пишет, что нужно добавить в файл NAMESPACE.\n\nЗамечание: `R CMD check` ловит не все подобные случаи использования. В\nчастности, `R CMD check` пропускает некоторые символы/функции в формулах и\nполностью пропустит собранные из текста выражения типа `parse(text =\n\"data.table(a = 1)\")`. Для обнаружения таких краевых случаев пакетам\nпотребуется хорошее покрытие тестами.\n\n### Шаг 2.2: Измените файл NAMESPACE\n\nОсновываясь на результатах `R CMD check`, импортируйте из `data.table` все\nнеобходимые функции, специальные символы, общие функции S3 и классы S4.\n\n---\n\n#: data.table.R:760\nmsgid \"column not found: %s\"\nmsgid_plural \"columns not found: %s\"\nmsgstr[0] \"列不存在: %s\"\n\n#: data.table.R:928\n#, fuzzy\n#| msgid \"\"\n#| \"The items in the 'by' or 'keyby' list are length(s) %s. Each must be \"\n#| \"length %d; the same length as there are rows in x (after subsetting if i \"\n#| \"is provided).\"\nmsgid \"\"\n\"The item in the 'by' or 'keyby' list is length %s. Each must be length %d; \"\n\"the same length as there are rows in x (after subsetting if i is provided).\"\nmsgid_plural \"\"\n\"The items in the 'by' or 'keyby' list have lengths %s. Each must be length \"\n\"%d; the same length as there are rows in x (after subsetting if i is \"\n\"provided).\"\nmsgstr[0] \"\"\n\"在'by'或'keyby'列表中的项长度为 %s 。每一项的长度须均为%d，即应与 x （或经 i \"\n\"筛选后的子集）中所包含行数相同。\"\n\n#: fmelt.R:27\nmsgid \"Pattern not found: [%s]\"\nmsgid_plural \"Patterns not found: [%s]\"\nmsgstr[0] \"未找到下列 pattern：[%s]\"\n\n#: fread.R:354\nmsgid \"stringsAsFactors=%s converted %d column: %s\\n\"\nmsgid_plural \"stringsAsFactors=%s converted %d columns: %s\\n\"\nmsgstr[0] \"\"\n\n#: merge.R:131\nmsgid \"\"\n\"merge.data.table() received %d unnamed argument in '...' which will be \"\n\"ignored.\"\nmsgid_plural \"\"\n\"merge.data.table() received %d unnamed arguments in '...' which will be \"\n\"ignored.\"\nmsgstr[0] \"\"\n\n#: merge.R:138\nmsgid \"\"\n\"merge.data.table() received %d unknown keyword argument which will be \"\n\"ignored: %s\"\nmsgid_plural \"\"\n\"merge.data.table() received %d unknown keyword arguments which will be \"\n\"ignored: %s\"\nmsgstr[0] \"\"\n\n#: merge.R:144\nmsgid \"%d unnamed argument in '...'\"\nmsgid_plural \"%d unnamed arguments in '...'\"\nmsgstr[0] \"\"\n\n#: merge.R:145\n#, fuzzy\n#| msgid \"Passed %d unknown and unnamed arguments.\"\nmsgid \"%d unknown keyword argument\"\nmsgid_plural \"%d unknown keyword arguments\"\nmsgstr[0] \"传入了 %d 个未知和未命名的参数。\"\n\n#: print.data.table.R:51\nmsgid \"Index: %s\\n\"\nmsgid_plural \"Indices: %s\\n\"\nmsgstr[0] \"索引(index): %s\\n\"\n\n#: print.data.table.R:290\nmsgid \"%d variable not shown: %s\\n\"\nmsgid_plural \"%d variables not shown: %s\\n\"\nmsgstr[0] \"\"\n\n#: setops.R:46\nmsgid \"unsupported column type found in x or y: %s\"\nmsgid_plural \"unsupported column types found in x or y: %s\"\nmsgstr[0] \"找到不支持的列类型在 x 或 y: %s\"\n\n#: test.data.table.R:288\nmsgid \"%d error out of %d. Search %s for test number %s. Duration: %s.\"\nmsgid_plural \"\"\n\"%d errors out of %d. Search %s for test numbers %s. Duration: %s.\"\nmsgstr[0] \"\"\n\"%2$d 中共产生 %1$d 个错误。搜索 %3$s 以定位测试编号 %4$s。用时：%5$s。\"\n\n#: test.data.table.R:298\nmsgid \"Caught %d warning outside the test() calls:\\n\"\nmsgid_plural \"Caught %d warnings outside the test() calls:\\n\"\nmsgstr[0] \"\"\n\n#: utils.R:43\n#, fuzzy\n#| msgid \"\"\n#| \"%s has some duplicated column name(s): %s. Please remove or rename the \"\n#| \"duplicate(s) and try again.\"\nmsgid \"\"\n\"%s has duplicated column name %s. Please remove or rename the duplicate and \"\n\"try again.\"\nmsgid_plural \"\"\n\"%s has duplicated column names %s. Please remove or rename the duplicates \"\n\"and try again.\"\nmsgstr[0] \"%s 中有如下重复的列名：%s。请移除或者重命名重复项后重试。\"\n\n---\n\n24. `setcolorder()` gains `before=` and `after=`, [#4358](https://github.com/Rdatatable/data.table/issues/4358). Thanks to Matthias Gomolka for the request, and both Benjamin Schwendinger and Xianghui Dong for implementing. Also thanks to Manuel López-Ibáñez for testing dev and mentioning needed documentation before release.\n\n25. `base::droplevels()` gains a fast method for `data.table`, [#647](https://github.com/Rdatatable/data.table/issues/647). Thanks to Steve Lianoglou for requesting, Boniface Kamgang and Martin Binder for testing, and Jan Gorecki and Benjamin Schwendinger for the PR. `fdroplevels()` for use on vectors has also been added.\n\n26. `shift()` now also supports `type=\"cyclic\"`, [#4451](https://github.com/Rdatatable/data.table/issues/4451). Arguments that are normally pushed out by `type=\"lag\"` or `type=\"lead\"` are re-introduced at this type at the first/last positions. Thanks to @RicoDiel for requesting, and Benjamin Schwendinger for the PR.\n\n ```R\n # Usage\n shift(1:5, n=-1:1, type=\"cyclic\")\n # [[1]]\n # [1] 2 3 4 5 1\n #\n # [[2]]\n # [1] 1 2 3 4 5\n #\n # [[3]]\n # [1] 5 1 2 3 4\n\n # Benchmark\n x = sample(1e9) # 3.7 GB\n microbenchmark::microbenchmark(\n shift(x, 1, type=\"cyclic\"),\n c(tail(x, 1), head(x,-1)),\n times = 10L,\n unit = \"s\"\n )\n # Unit: seconds\n # expr min lq mean median uq max neval\n # shift(x, 1, type = \"cyclic\") 1.57 1.67 1.71 1.68 1.70 2.03 10\n # c(tail(x, 1), head(x, -1)) 6.96 7.16 7.49 7.32 7.64 8.60 10\n ```\n\n27. `fread()` now supports \"0\" and \"1\" in `na.strings`, [#2927](https://github.com/Rdatatable/data.table/issues/2927). Previously this was not permitted since \"0\" and \"1\" can be recognized as boolean values. Note that it is still not permitted to use \"0\" and \"1\" in `na.strings` in combination with `logical01 = TRUE`. Thanks to @msgoussi for the request, and Benjamin Schwendinger for the PR.\n\n28. `setkey()` now supports type `raw` as value columns (not as key columns), [#5100](https://github.com/Rdatatable/data.table/issues/5100). Thanks Hugh Parsonage for requesting, and Benjamin Schwendinger for the PR.\n\n29. `shift()` is now optimized by group, [#1534](https://github.com/Rdatatable/data.table/issues/1534). Thanks to Gerhard Nachtmann for requesting, and Benjamin Schwendinger for the PR. Thanks to @neovom for testing dev and filing a bug report, [#5547](https://github.com/Rdatatable/data.table/issues/5547) which was fixed before release. This helped also in improving the logic for when to turn on optimization by group in general, making it more robust.\n\n ```R\n N = 1e7\n DT = data.table(x=sample(N), y=sample(1e6,N,TRUE))\n shift_no_opt = shift # different name not optimized as a way to compare\n microbenchmark(\n DT[, c(NA, head(x,-1)), y],\n DT[, shift_no_opt(x, 1, type=\"lag\"), y],\n DT[, shift(x, 1, type=\"lag\"), y],\n times=10L, unit=\"s\")\n # Unit: seconds\n # expr min lq mean median uq max neval\n # DT[, c(NA, head(x, -1)), y] 8.7620 9.0240 9.1870 9.2800 9.3700 9.4110 10\n # DT[, shift_no_opt(x, 1, type = \"lag\"), y] 20.5500 20.9000 21.1600 21.3200 21.4400 21.5200 10\n # DT[, shift(x, 1, type = \"lag\"), y] 0.4865 0.5238 0.5463 0.5446 0.5725 0.5982 10\n ```\n\n---\n\n# test regression on over-allocation (selfref) on unique() which uses new subsetDT()\nbla <- data.table(x=c(1,1,2,2), y=c(1,1,1,1))\ntest(1342, unique(bla)[, bla := 2L], data.table(x=c(1,2),y=1,bla=2L))\n\n# blank and NA fields in logical columns\ntest(1343.1, fread(\"A,B\\n1,TRUE\\n2,\\n3,False\"), data.table(A=1:3, B=c(\"TRUE\",\"\",\"False\")))\ntest(1343.2, fread(\"A,B\\n1,True\\n2,\\n3,false\"), data.table(A=1:3, B=c(\"True\",\"\",\"false\")))\ntest(1343.3, fread(\"A,B\\n1,TRUE\\n2,\\n3,FALSE\"), data.table(A=1:3, B=c(TRUE,NA,FALSE)))\ntest(1343.4, fread(\"A,B\\n1,True\\n2,\\n3,False\"), data.table(A=1:3, B=c(TRUE,NA,FALSE)))\ntest(1343.5, fread(\"A,B\\n1,true\\n2,\\n3,false\"), data.table(A=1:3, B=c(TRUE,NA,FALSE)))\ntest(1343.6, fread(\"A,B\\n1,true\\n2,NA\\n3,\"), data.table(A=1:3, B=c(TRUE,NA,NA)))\ntest(1344.1, fread(\"A,B\\n1,2\\n0,3\\n,1\\n\", logical01=FALSE), data.table(A=c(1L,0L,NA), B=c(2L,3L,1L)))\ntest(1344.2, fread(\"A,B\\n1,2\\n0,3\\n,1\\n\", logical01=TRUE), data.table(A=c(TRUE,FALSE,NA), B=c(2L,3L,1L)))\ntest(1344.3, fread(\"A,B\\nY,2\\nN,3\\nNA,1\\n\", logicalYN=FALSE), data.table(A=c('Y','N',NA), B=c(2L,3L,1L)))\ntest(1344.4, fread(\"A,B\\nY,2\\nN,3\\nNA,1\\n\", logicalYN=TRUE), data.table(A=c(TRUE,FALSE,NA), B=c(2L,3L,1L)))\ntest(1344.5, fread(\"A,B\\nY,2\\nN,3\\n,1\\n\", logicalYN=FALSE, na.strings=\"\"), data.table(A=c('Y','N',NA), B=c(2L,3L,1L)))\ntest(1344.6, fread(\"A,B\\nY,2\\nN,3\\n,1\\n\", logicalYN=TRUE, na.strings=\"\"), data.table(A=c(TRUE,FALSE,NA), B=c(2L,3L,1L)))\n\n# .N now available in i\nDT = data.table(a=1:3,b=1:6)\ntest(1348, DT[.N], DT[6])\ntest(1349, DT[.N-1:3], DT[5:3])\ntest(1350, DT[.N+1], DT[NA])\n\n# Adding test to catch any future regressions - #734\ndt = data.table(id = rep(c('a','b'), each=2), val = rep(c(1,2,3), times=c(1,2,1)))\nsetkey(dt, id, val)\ntest(1351.1, dt[J(\"a\"), val], c(1,2))\ntest(1351.2, dt[J('a'), range(val)], c(1,2))\n\n# New feature: .() in j and .() in by\nDT = data.table(a=1:3, b=1:6, c=LETTERS[1:6])\ntest(1352.1, DT[,.(b)], DT[,list(b)])\ntest(1352.2, DT[,.(b,c)], DT[,c(\"b\",\"c\"),with=FALSE])\ntest(1352.3, DT[,.(sum(b)),by=a], DT[,sum(b),by=a])\ntest(1352.4, DT[,.(MySum=sum(b)), by=a], data.table(a=1:3, MySum=c(5L,7L,9L)))\ntest(1352.5, DT[,sum(b),by=.(a)], DT[,sum(b),by=a])\ntest(1352.6, DT[,sum(b),by=.(a%%2)], DT[,sum(b),by=a%%2])\ntest(1352.7, DT[,sum(b),by=.(Grp=a%%2)], DT[,sum(b),by=list(Grp=a%%2)])\ntest(1352.8, DT[,sum(b),by=.(a%%2,c)], DT[,sum(b),by=list(a%%2,c)])\n\n# that :=NULL together with i is now an error\nDT = data.table(a=1:3, b=1:6, c=list(7, 8, 9, 8, 7, 6))\ntest(1353.1, DT[2, b:=NULL], error=\"When deleting columns, i should not be provided\")\ntest(1353.2, DT[2, c(\"a\",\"b\"):=list(42, NULL)], error=\"When deleting columns, i should not be provided\")\n# #5526: friendlier error nudging to the correct way to sub-assign NULL to list columns\ntest(1353.3, DT[2, c := NULL], error=\"Invalid attempt to delete a list column.*did you intend to add NULL\")\ntest(1353.4, DT[2, c := .(NULL)], error=\"Invalid attempt to delete a list column.*did you intend to add NULL\")\ntest(1353.5, DT[2, `:=`(b=2, c=NULL)], error=\"Invalid attempt to delete a list column.*did you intend to add NULL\")\ntest(1353.6, DT[2, d := NULL], error=\"Doubly-invalid attempt to delete a non-existent column while also providing i\")\n\n# order optimisation caused trouble due to chaining because of 'substitute(x)' usage in [.data.table.\nset.seed(1L)\nX = data.table(id=1:10, val1=sample(3,10,TRUE))\nY = data.table(val1=1:4, val2=8:5, key=\"val1\")\nsetkey(X, val1)\ntest(1354, X[Y, val2 := i.val2, allow.cartesian=TRUE][, val1 := NULL][order(id)], data.table(id=1:10, val2=as.integer(c(8,7,7,6,8,6,6,7,7,8))))\n\n# Fix for #475, setDT(CO2) should error, as it's trying to modify the object whose binding is locked.\n# NB: requires datasets be attached -- no error thrown on datasets::CO2 or CO2=datasets::CO2 or get(\"CO2\", asNamespace(\"CO2\"))\ntest(1355, setDT(CO2), error=\"Cannot convert 'CO2' to data.table by reference because binding is locked.\")\n\n---\n\nsetkey = function(x, ..., verbose=getOption(\"datatable.verbose\"), physical=TRUE)\n{\n if (is.character(x)) stopf(\"x may no longer be the character name of the data.table. The possibility was undocumented and has been removed.\")\n cols = as.character(substitute(list(...))[-1L])\n if (!length(cols)) { cols=colnames(x) }\n else if (identical(cols,\"NULL\")) cols=NULL\n setkeyv(x, cols, verbose=verbose, physical=physical)\n}\n\n# FR #1442\nsetindex = function(...) setkey(..., physical=FALSE)\nsetindexv = function(x, cols, verbose=getOption(\"datatable.verbose\")) {\n if (is.list(cols)) {\n sapply(cols, setkeyv, x=x, verbose=verbose, physical=FALSE)\n invisible(x)\n } else {\n setkeyv(x, cols, verbose=verbose, physical=FALSE)\n }\n}\n\nsetkeyv = function(x, cols, verbose=getOption(\"datatable.verbose\"), physical=TRUE)\n{\n if (is.null(cols)) { # this is done on a data.frame when !cedta at top of [.data.table\n if (physical) setattr(x,\"sorted\",NULL)\n setattr(x,\"index\",NULL) # setkey(DT,NULL) also clears secondary keys. setindex(DT,NULL) just clears secondary keys.\n return(invisible(x))\n }\n if (!missing(verbose)) {\n stopifnot(isTRUEorFALSE(verbose))\n # set the global verbose option because that is fetched from C code without having to pass it through\n oldverbose = options(datatable.verbose=verbose)\n on.exit(options(oldverbose))\n }\n if (!is.data.table(x)) stopf(\"x is not a data.table\")\n if (!is.character(cols)) stopf(\"cols is not a character vector. Please see further information in ?%s.\", \"setkey\")\n if (physical && .Call(C_islocked, x)) stopf(\"Setting a physical key on .SD is reserved for possible future use; to modify the original data's order by group. Try setindex() instead. Or, set*(copy(.SD)) as a (slow) last resort.\")\n if (!length(cols)) {\n warningf(\"cols is a character vector of zero length. Removed the key, but use NULL instead, or wrap with suppressWarnings() to avoid this warning.\")\n setattr(x,\"sorted\",NULL)\n return(invisible(x))\n }\n if (identical(cols,\"\")) stopf(\"cols is the empty string. Use NULL to remove the key.\")\n if (!all(nzchar(cols))) stopf(\"cols contains some blanks.\")\n cols = gsub(\"`\", \"\", cols, fixed = TRUE)\n miss = !(cols %chin% colnames(x))\n if (any(miss)) stopf(\"some columns are not in the data.table: %s\", brackify(cols[miss]), class = \"dt_missing_column_error\")\n\n if (physical && identical(head(key(x), length(cols)), cols)){ ## for !physical we need to compute groups as well #4387\n ## key is present but x has a longer key. No sorting needed, only attribute is changed to shorter key.\n setattr(x,\"sorted\",cols)\n return(invisible(x))\n }\n\n if (\".xi\" %chin% names(x)) stopf(\"x contains a column called '.xi'. Conflicts with internal use by data.table.\")\n for (i in cols) {\n .xi = x[[i]] # [[ is copy on write, otherwise checking type would be copying each column\n if (!typeof(.xi) %chin% ORDERING_TYPES) stopf(\"Column '%s' is type '%s' which is not supported as a key column type, currently.\", i, typeof(.xi), class=\"dt_unsortable_type_error\")\n }\n if (!is.character(cols) || length(cols)<1L) internal_error(\"'cols' should be character at this point\") # nocov\n\n---\n\n\\name{tables}\n\\alias{tables}\n\\title{Display 'data.table' metadata }\n\\description{\n Convenience function for concisely summarizing some metadata of all \\code{data.table}s in memory (or an optionally specified environment).\n}\n\\usage{\ntables(mb=type_size, order.col=\"NAME\", width=80,\n env=parent.frame(), silent=FALSE, index=FALSE)\n}\n\\arguments{\n \\item{mb}{ a function which accepts a \\code{data.table} and returns its size in bytes. By default, \\code{type_size} (same as \\code{TRUE}) provides a fast lower bound by excluding the size of character strings in R's global cache (which may be shared) and excluding the size of list column items (which also may be shared). A column \\code{\"MB\"} is included in the output unless \\code{FALSE} or \\code{NULL}. }\n \\item{order.col}{ Column name (\\code{character}) by which to sort the output. }\n \\item{width}{ \\code{integer}; number of characters beyond which the output for each of the columns \\code{COLS}, \\code{KEY}, and \\code{INDICES} are truncated. }\n \\item{env}{ An \\code{environment}, typically the \\code{.GlobalEnv} by default, see Details. }\n \\item{silent}{ \\code{logical}; should the output be printed? }\n \\item{index}{ \\code{logical}; if \\code{TRUE}, the column \\code{INDICES} is added to indicate the indices assorted with each object, see \\code{\\link{indices}}. }\n}\n\\details{\nUsually \\code{tables()} is executed at the prompt, where \\code{parent.frame()} returns \\code{.GlobalEnv}. \\code{tables()} may also be useful inside functions where \\code{parent.frame()} is the local scope of the function; in such a scenario, simply set it to \\code{.GlobalEnv} to get the same behaviour as at prompt.\n\n\\code{mb = utils::object.size} provides a higher and more accurate estimate of size, but may take longer. Its default \\code{units=\"b\"} is appropriate.\n\nSetting \\code{silent=TRUE} prints nothing; the metadata is returned as a \\code{data.table} invisibly whether \\code{silent} is \\code{TRUE} or \\code{FALSE}.\n}\n\\value{\n A \\code{data.table} containing the information printed.\n}\n\\seealso{ \\code{\\link{data.table}}, \\code{\\link{setkey}}, \\code{\\link{ls}}, \\code{\\link{objects}}, \\code{\\link{object.size}} }\n\\examples{\nDT = data.table(A=1:10, B=letters[1:10])\nDT2 = data.table(A=1:10000, ColB=10000:1)\nsetkey(DT,B)\ntables()\n}\n\\keyword{ data }\n\n---\n\n#: onAttach.R:26\n#, c-format\nmsgid \"Latest news: r-datatable.com\"\nmsgstr \"Últimas notícias: r-datatable.com\"\n\n#: onAttach.R:27\nmsgid \"TRANSLATION CHECK\"\nmsgstr \"VERIFICAÇÃO DE TRADUÇÃO\"\n\n#: onAttach.R:29\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"Running data.table in English; package support is available in English only. \"\n\"When searching for online help, be sure to also check for the English error \"\n\"message. This can be obtained by looking at the po/R-.po and po/\"\n\".po files in the package source, where the native language and \"\n\"English error messages can be found side-by-side.%s\\n\"\n\"**********\"\nmsgstr \"\"\n\"**********\\n\"\n\"Executando data.table em português; o suporte ao pacote está disponível \"\n\"apenas em inglês. Ao procurar ajuda online, certifique-se de verificar \"\n\"também a mensagem de erro em inglês. Isso pode ser obtido examinando os \"\n\"arquivos po/R-pt_BR.po e po/pt_BR.po no código-fonte do pacote, onde as \"\n\"mensagens de erro no idioma nativo e em inglês podem ser encontradas lado a \"\n\"lado.%s\\n\"\n\"**********\"\n\n#: onAttach.R:30\nmsgid \"\"\n\"You can also try calling Sys.setLanguage('en') prior to reproducing the \"\n\"error message.\"\nmsgstr \"\"\n\"Você também pode tentar chamar Sys.setLanguage('en') antes de reproduzir a \"\n\"mensagem de erro.\"\n\n#: onAttach.R:34\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"This development version of data.table was built more than 4 weeks ago. \"\n\"Please update: data.table::update_dev_pkg()\\n\"\n\"**********\"\nmsgstr \"\"\n\"**********\\n\"\n\"Esta versão de desenvolvimento do data.table foi construída há mais de 4 \"\n\"semanas. Por favor, atualize: data.table::update_dev_pkg()\\n\"\n\"**********\"\n\n#: onAttach.R:36\n#, c-format\nmsgid \"\"\n\"**********\\n\"\n\"This installation of data.table has not detected OpenMP support. It should \"\n\"still work but in single-threaded mode.\"\nmsgstr \"\"\n\"**********\\n\"\n\"Esta instalação do data.table não detectou suporte ao OpenMP. Ainda deve \"\n\"funcionar, mas em modo de single-threaded.\"\n\n#: onAttach.R:38\n#, c-format\nmsgid \"\"\n\"This is a Mac. Please read https://mac.r-project.org/openmp/. Please engage \"\n\"with Apple and ask them for support. Check r-datatable.com for updates, and \"\n\"our Mac instructions here: https://github.com/Rdatatable/data.table/wiki/\"\n\"Installation. After several years of many reports of installation problems \"\n\"on Mac, it's time to gingerly point out that there have been no similar \"\n\"problems on Windows or Linux.\\n\"\n\"**********\"\nmsgstr \"\"\n\"Este é um Mac. Por favor, leia https://mac.r-project.org/openmp/. Por favor, \"\n\"envolva-se com a Apple e peça suporte. Verifique r-datatable.com para \"\n\"atualizações e nossas instruções para Mac aqui: https://github.com/\"\n\"Rdatatable/data.table/wiki/Installation. Após vários anos de muitos relatos \"\n\"de problemas de instalação no Mac, é hora de apontar cuidadosamente que não \"\n\"houve problemas semelhantes no Windows ou Linux.\\n\"\n\"**********\"\n\n#: onAttach.R:40\n#, c-format\nmsgid \"\"\n\"This is %s. This warning should not normally occur on Windows or Linux where \"\n\"OpenMP is turned on by data.table's configure script by passing -fopenmp to \"\n\"the compiler. If you see this warning on Windows or Linux, please file a \"\n\"GitHub issue.\\n\"\n\"**********\"\nmsgstr \"\"\n\"Este é %s. Este aviso normalmente não deve ocorrer no Windows ou Linux, onde \"\n\"o OpenMP é ativado pelo script de configuração do data.table passando \"\n\"-fopenmp para o compilador. Se você vir este aviso no Windows ou Linux, por \"\n\"favor, relate no rastreador de problemas no GitHub.\\n\"\n\"**********\"\n\n#: onLoad.R:5\n#, c-format\nmsgid \"\"\n\"Option 'datatable.nomatch' is defined but is now ignored. Please see note 11 \"\n\"in v1.12.4 NEWS (Oct 2019), and note 14 in v1.14.2.\"\nmsgstr \"\"\n\"Opção 'datatable.nomatch' está definida, mas agora é ignorada. Por favor, \"\n\"veja a nota 11 nas notícias de v1.12.4 (Outubro de 2019) e a nota 14 em \"\n\"v1.14.2.\"\n\n---\n\n### g) ¿Por qué mantener `j` tan flexible?\n\nPara mantener una sintaxis consistente y seguir usando funciones base ya existentes (y conocidas), en lugar de tener que aprender nuevas funciones. Para ilustrar, usemos el `data.table` `DT` que creamos al principio, en la sección [¿Qué es un data.table?](#what-is-datatable-1a).\n\n#### -- ¿Cómo podemos concatenar las columnas `a` y `b` para cada grupo en `ID`?\n\n```{r}\nDT[, .(val = c(a,b)), by = ID]\n```\n\n* Eso es todo. No se requiere sintaxis especial. Solo necesitamos saber la función base `c()`, que concatena vectores, y [la sugerencia anterior](#tip-1).\n\n#### --¿Qué sucede si queremos tener todos los valores de las columnas `a` y `b` concatenados, pero devueltos como una columna de lista?\n\n```{r}\nDT[, .(val = list(c(a,b))), by = ID]\n```\n\n* Aquí, primero concatenamos los valores con `c(a,b)` para cada grupo y los envolvemos con `list()`. Por lo tanto, para cada grupo, devolvemos una lista de todos los valores concatenados.\n\n* Tenga en cuenta que estas comas son solo para visualización. Una columna de lista puede contener cualquier objeto en cada celda; en este ejemplo, cada celda es un vector, y algunas celdas contienen vectores más largos que otras.\n\nUna vez que empiece a internalizar el uso de `j`, se dará cuenta de lo poderosa que puede ser la sintaxis. Una forma muy útil de comprenderla es experimentando con la ayuda de `print()`.\n\nPor ejemplo:\n\n```{r}\n## look at the difference between\nDT[, print(c(a,b)), by = ID] # (1)\n\n## and\nDT[, print(list(c(a,b))), by = ID] # (2)\n```\n\n```{r, echo = FALSE}\np = function(x) paste0('', paste(deparse(substitute(x)), collapse = ' '), ' = ', x, '')\n```\n\nEn (1), para cada grupo, se devuelve un vector, con longitud = 6,4,2. Sin embargo, (2) devuelve una lista de longitud 1 para cada grupo, cuyo primer elemento contiene vectores de longitud 6,4,2. Por lo tanto, (1) da como resultado una longitud de `{r} p(6+4+2)`, mientras que (2) devuelve `{r} p(1+1+1)`.\n\nLa flexibilidad de j nos permite almacenar cualquier objeto de lista como elemento de data.table. Por ejemplo, cuando los modelos estadísticos se ajustan a grupos, estos modelos pueden almacenarse en una tabla data.table. El código es conciso y fácil de entender.\n\n```{r}\n## Do long distance flights cover up departure delay more than short distance flights?\n## Does cover up vary by month?\nflights[, `:=`(makeup = dep_delay - arr_delay)]\n\nmakeup.models <- flights[, .(fit = list(lm(makeup ~ distance))), by = .(month)]\nmakeup.models[, .(coefdist = coef(fit[[1]])[2], rsq = summary(fit[[1]])$r.squared), by = .(month)]\n```\n\nUsando data.frames, necesitamos un código más complicado para obtener el mismo resultado.\n\n```{r}\nsetDF(flights)\nflights.split <- split(flights, f = flights$month)\nmakeup.models.list <- lapply(flights.split, function(df) c(month = df$month[1], fit = list(lm(makeup ~ distance, data = df))))\nmakeup.models.df <- do.call(rbind, makeup.models.list)\ndata.frame(t(sapply(\n makeup.models.df[, \"fit\"],\n function(model) c(coefdist = coef(model)[2L], rsq = summary(model)$r.squared)\n)))\nsetDT(flights)\n```\n\n## Resumen\n\nLa forma general de la sintaxis de `data.table` es:\n\n```r\nDT[i, j, by]\n```\n\nHemos visto hasta ahora que,\n\n#### Usando `i`:\n\n* Podemos filtrar filas de manera similar a un `data.frame`, excepto que no es necesario usar `DT$` repetidamente, ya que las columnas dentro del marco de un `data.table` se ven como si fueran *variables*.\n\n* También podemos ordenar una `data.table` usando `order()`, que internamente usa el orden rápido de data.table para un mejor rendimiento.\n\nPodemos hacer mucho más en `i` al introducir claves en `data.table`, lo que permite filtrados y uniones ultrarrápidos. Veremos esto en las viñetas [`vignette(\"datatable-keys-fast-subset\", package=\"data.table\")`](datatable-keys-fast-subset.html) y [`vignette(\"datatable-joins\", package=\"data.table\")`](datatable-joins.html).\n\n#### Usando `j`:\n\n---\n\n# Use existing index even when auto index is disabled #1422\nd = data.table(k=3:1) # subset - no index\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=TRUE)\ntest(1666.01, d[k==1L, verbose=TRUE], d[3L], output=\"Creating new index 'k'\")\nd = data.table(k=3:1)\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=FALSE)\ntest(1666.02, d[k==1L, verbose=TRUE], notOutput=\"Creating new index\") # do not create index\nd = data.table(k=3:1)\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=FALSE)\ntest(1666.03, d[k==1L, verbose=TRUE], notOutput=\"Creating new index\")\nd = data.table(k=3:1)\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=TRUE)\ntest(1666.04, d[k==1L, verbose=TRUE], notOutput=\"Creating new index\")\nd = data.table(k=3:1) # subset - index\nsetindex(d, k)\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=TRUE)\ntest(1666.05, d[k==1L, verbose=TRUE], d[3L], output=\"Optimized subsetting with index 'k'\")\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=FALSE)\ntest(1666.06, d[k==1L, verbose=TRUE], d[3L], output=\"Optimized subsetting with index 'k'\")\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=FALSE)\ntest(1666.07, d[k==1L, verbose=TRUE], notOutput=\"Using existing index\") # not using existing index\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=TRUE)\ntest(1666.08, d[k==1L, verbose=TRUE], notOutput=\"Using existing index\")\nd1 = data.table(k=3:1) # join - no index\nd2 = data.table(k=2:4)\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=TRUE)\ntest(1666.09, d1[d2, on=\"k\", verbose=TRUE], d1[d2, on=\"k\"], output=\"ad hoc\")\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=FALSE)\ntest(1666.10, d1[d2, on=\"k\", verbose=TRUE], d1[d2, on=\"k\"], output=\"ad hoc\")\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=FALSE)\ntest(1666.11, d1[d2, on=\"k\", verbose=TRUE], notOutput=\"Looking for existing (secondary) index\") # not looking for index\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=TRUE)\ntest(1666.12, d1[d2, on=\"k\", verbose=TRUE], notOutput=\"Looking for existing (secondary) index\")\nd1 = data.table(k=3:1,v1=10:12) # join - index\nd2 = data.table(k=2:4,v2=20:22)\nsetindex(d1, k)\nans = data.table(k=2:4, v1=c(11L,10L,NA), v2=20:22)\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=TRUE)\ntest(1666.13, d1[d2, on=\"k\", verbose=TRUE], ans, output=\"existing index\")\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=FALSE)\ntest(1666.14, d1[d2, on=\"k\", verbose=TRUE], ans, output=\"existing index\")\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=FALSE)\ntest(1666.15, d1[d2, on=\"k\", verbose=TRUE], ans, output='ad hoc')\noptions(\"datatable.use.index\"=FALSE, \"datatable.auto.index\"=TRUE)\ntest(1666.16, d1[d2, on=\"k\", verbose=TRUE], ans, output='ad hoc')\n# reset defaults\noptions(\"datatable.use.index\"=TRUE, \"datatable.auto.index\"=TRUE)\n\n#testing fix to #1654 (dcast should only error when _using_ duplicated names)\nDT <- data.table(a = 1:4, a = 1:4, id = rep(1:4, 2), V1 = 8:1)\ntest(1667.1, dcast(DT, id ~ rowid(id), value.var = \"V1\"),\n output = \" id 1 2\\n1: 1 8 4\\n2: 2 7 3\\n3: 3 6 2\\n4: 4 5 1\")\nDT <- data.table(a = 1:4, id = 1:4, id = rep(1:4, 2), V1 = 8:1)\ntest(1667.2, dcast(DT, id ~ rowid(id), value.var = \"V1\"), error = \"data.table to cast\")\n\n# fix for #1672\ntest(1668, chmatch(c(\"a\",\"b\"), c(\"a\",\"c\"), nomatch = integer()), c(1L, NA_integer_))\n\n---\n\n/**\n * This function is invoked by `freadMain` before the main scan of the input\n * file. It should allocate the resulting `DataTable` structure and prepare\n * to receive the data in chunks.\n *\n * Additionally, this function will be invoked if the main scan was\n * unsuccessful. This may happen either because there were out-of-sample type\n * exceptions (i.e. a value was found in one of the columns that wasn't\n * acceptable for that column's type), or if the initial estimate of the file's\n * number of rows turned out to be too conservative, and more rows has to be\n * appended to the DataTable.\n *\n * @param types\n * array of type codes for each column. Same as in the `userOverride`\n * function.\n *\n * @param sizes\n * the size (in bytes) of each column within the buffer(s) that will be\n * passed to `pushBuffer()` during the scan. This array should be saved for\n * later use. It exists mostly for convenience, since the size of each\n * non-skipped column may be determined from that column's type.\n *\n * @param ncols\n * number of columns in the CSV file. This is the size of arrays `types` and\n * `sizes`.\n *\n * @param ndrop\n * count of columns with type CT_DROP. This parameter is provided for\n * convenience, since it can always be computed from `types`. The resulting\n * datatable will have `ncols - ndrop` columns.\n *\n * @param nrows\n * the number of rows to allocate for the datatable. This number of rows is\n * estimated during the initial pre-scan, and then adjusted upwards to\n * account for possible variation. It is very unlikely that this number\n * underestimates the final row count.\n *\n * @return\n * this function should return the total size of the Datatable created (for\n * reporting purposes). If the return value is 0, then it indicates an error\n * and `fread` will abort.\n */\nsize_t allocateDT(int8_t *types, int8_t *sizes, int ncols, int ndrop,\n size_t nrows);\n\n\n/**\n * Called once at the beginning of each thread before it starts scanning the\n * input file. If the file needs to be rescanned because of out-of-type\n * exceptions, this will be called again before the second scan.\n */\nvoid prepareThreadContext(ThreadLocalFreadParsingContext *ctx);\n\n\n/**\n * Give upstream the chance to modify the scanned buffers after the thread\n * finished reading its chunk but before it enters the \"ordered\" section.\n * Variable `ctx.DTi` is not available at this moment.\n */\nvoid postprocessBuffer(ThreadLocalFreadParsingContext *ctx);\n\n\n/**\n * Callback invoked within the \"ordered\" section for each thread. Only\n * lightweight processing should be performed here, since this section stalls\n * execution of any other thread!\n */\nvoid orderBuffer(ThreadLocalFreadParsingContext *ctx);\n\n\n/**\n * This function transfers the scanned input data into the final DataTable\n * structure. It will be called many times, and from parallel threads (thus\n * it should not attempt to modify any global variables). Its primary job is\n * to transpose the data: convert from row-major order within each buffer\n * into the column-major order for the resulting DataTable.\n */\nvoid pushBuffer(ThreadLocalFreadParsingContext *ctx);\n\n\n/**\n * Called at the end to specify what the actual number of rows in the datatable\n * was. The function should adjust the datatable, reallocing the buffers if\n * necessary.\n * If the input file needs to be rescanned due to some columns having wrong\n * column types, then this function will be called once after the file is\n * finished scanning but before any calls to `reallocColType()`, and then the\n * second time after the entire input file was scanned again.\n */\nvoid setFinalNrow(size_t nrows);\n\n\n/**\n * Called at the end to delete columns added due to too high user guess for fill.\n */\nvoid dropFilledCols(int* dropArg, int ndrop);\n\n/**\n * Free any srtuctures associated with the thread-local parsing context.\n */\nvoid freeThreadContext(ThreadLocalFreadParsingContext *ctx);\n\n---\n\n#: data.table.R:448\n#, c-format\nmsgid \"\"\n\"i is invalid type (matrix). Perhaps in future a 2 column matrix could return \"\n\"a list of elements of DT (in the spirit of A[B] in FAQ 2.14). Please report \"\n\"to data.table issue tracker if you'd like this, or add your comments to FR \"\n\"#657.\"\nmsgstr \"\"\n\"i不是一个有效的类型(矩阵)。也许在以后一个包含两列的矩阵会返回包含一串元素的\"\n\"DT (请参考问答集2.14的A[B])。如果你有需求，请将此问题汇报给data.table 问题追\"\n\"踪器或者是在FR中留下你的想法\"\n\n#: data.table.R:471\n#, fuzzy, c-format\n#| msgid \"\"\n#| \"When i is a data.table (or character vector), the columns to join by must \"\n#| \"be specified using 'on=' argument (see ?data.table), by keying x (i.e. \"\n#| \"sorted, and, marked as sorted, see ?setkey), or by sharing column names \"\n#| \"between x and i (i.e., a natural join). Keyed joins might have further \"\n#| \"speed benefits on very large data due to x being sorted in RAM.\"\nmsgid \"\"\n\"When i is a data.table (or character vector), the columns to join by must be \"\n\"specified using the 'on=' argument (see ?data.table); by keying x (i.e., x \"\n\"is sorted and marked as such, see ?setkey); or by using 'on = .NATURAL' to \"\n\"indicate using the shared column names between x and i (i.e., a natural \"\n\"join). Keyed joins might have further speed benefits on very large data due \"\n\"to x being sorted in RAM.\"\nmsgstr \"\"\n\"但i是一个 data.table (或者是字符向量)，必须使用 'on=' 参数指明参与连接的列 \"\n\"(参见 ?data.table)，可以是keying x(比如，已排序过，和标记已排序过，请参见?\"\n\"setkey)，或者是在x和i共用列的名字(比如，自然连接)。如果x有在内存被排序过，键\"\n\"(keyed)连接的速度会在非常大的数据上有较明显的提高。\"\n\n#: data.table.R:479\n#, c-format\nmsgid \"Attempting to do natural join but no common columns in provided tables\"\nmsgstr \"尝试进行自然连接然而并没有找到表格中相同的列\"\n\n#: data.table.R:482\nmsgid \"Joining but 'x' has no key, natural join using all 'x' columns\"\nmsgstr \"\"\n\n#: data.table.R:484\nmsgid \"Joining but 'x' has no key, natural join using: %s\"\nmsgstr \"\"\n\n#: data.table.R:513\nmsgid \"not-join called with 'by=.EACHI'; Replacing !i with i=setdiff_(x,i) ...\"\nmsgstr \"\"\n\n#: data.table.R:544\nmsgid \"Constructing irows for '!byjoin || nqbyjoin' ...\"\nmsgstr \"\"\n\n#: data.table.R:558 mergelist.R:124\n#, c-format\nmsgid \"\"\n\"Joining resulted in many-to-many join. Perform quality check on your data, \"\n\"use mult!='all', or set 'datatable.join.many' option to TRUE to allow rows \"\n\"explosion.\"\nmsgstr \"\"\n\n#: data.table.R:596\nmsgid \"Reorder irows for 'mult==\\\"all\\\" && !allGrp1' ...\"\nmsgstr \"\"\n\n#: data.table.R:608\nmsgid \"Reordering %d rows after bmerge done in ...\"\nmsgstr \"\"\n\n#: data.table.R:625\n#, c-format\nmsgid \"logical error. i is not a data.table, but 'on' argument is provided.\"\nmsgstr \"逻辑错误。当 i 并非一个 data.table时，不应提供'on'参数\"\n\n#: data.table.R:629\n#, c-format\nmsgid \"i has evaluated to type %s. Expecting logical, integer or double.\"\nmsgstr \"经计算 i 为 %s 类型。需要布尔类型，整型或浮点型。\"\n\n#: data.table.R:651\n#, c-format\nmsgid \"\"\n\"i evaluates to a logical vector length %d but there are %d rows. Recycling \"\n\"of logical i is no longer allowed as it hides more bugs than is worth the \"\n\"rare convenience. Explicitly use rep(...,length=.N) if you really need to \"\n\"recycle.\"\nmsgstr \"\"\n\"经计算 i 为长度为 %d 的逻辑向量，但数据框有 %d 行。循环补齐循环补齐逻辑向量 \"\n\"i 的特性虽然在少数情况下使用方便，但这种行为会隐藏更多的 bug，因此现已不被允\"\n\"许。若确实需要循环补齐，请直接使用 rep(...,length=.N)。\"\n\n#: data.table.R:654\n#, c-format\nmsgid \"\"\n\"Please use nomatch=NULL instead of nomatch=0; see news item 5 in v1.12.0 \"\n\"(Jan 2019)\"\nmsgstr \"\"\n\"请使用 nomatch=NULL 而非 nomatch=0；参见 v1.12.0 (2019年1月) 中更新条目 5\"\n\n#: data.table.R:669\nmsgid \"Inverting irows for notjoin done in ...\"\nmsgstr \"\"\n\n#: data.table.R:725\n#, c-format\nmsgid \"`:=` is only supported under with=TRUE, see ?`:=`.\"\nmsgstr \"\"\n\n#: data.table.R:767\n#, c-format\nmsgid \"Item %d of j is %d which is outside the column number range [1,ncol=%d]\"\nmsgstr \"j 中的第 %d 项的数值为 %d，已超出列索引的范围内1,ncol=%d]\"\n\n#: data.table.R:770\n#, c-format\nmsgid \"j mixes positives and negatives\"\nmsgstr \"j 中同时存在正数和负数\"\n\n#: data.table.R:778\n#, c-format\nmsgid \"\"\n\"When with=FALSE, j-argument should be of type logical/character/integer \"\n\"indicating the columns to select.\"\nmsgstr \"当 with=FALSE，参数 j 必须为布尔型/字符型/整型之一，表征要选择的列。\"\n\n---\n\ntest(6001.211, frollsum(1:3, 0), c(0,0,0), options=c(\"datatable.verbose\"=TRUE), output=\"window width of size 0\")\ntest(6001.212, frollsum(1:3, 0, fill=99), c(0,0,0))\ntest(6001.213, frollsum(c(1:2,NA), 0), c(0,0,0))\ntest(6001.214, frollsum(c(1:2,NA), 0, na.rm=TRUE), c(0,0,0))\ntest(6001.215, frollsum(1:3, 0, algo=\"exact\"), c(0,0,0), options=c(\"datatable.verbose\"=TRUE), output=\"window width of size 0\")\ntest(6001.216, frollsum(c(1:2,NA), 0, algo=\"exact\"), c(0,0,0))\ntest(6001.217, frollsum(c(1:2,NA), 0, algo=\"exact\", na.rm=TRUE), c(0,0,0))\ntest(6001.221, frollsum(adaptive=TRUE, 1:3, c(2,0,2)), c(NA,0,5))\ntest(6001.222, frollsum(adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,0,5))\ntest(6001.223, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,0,NA))\ntest(6001.224, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,0,2))\ntest(6001.225, frollsum(adaptive=TRUE, 1:3, c(2,0,2), algo=\"exact\"), c(NA,0,5))\ntest(6001.226, frollsum(adaptive=TRUE, 1:3, c(2,0,2), fill=99, algo=\"exact\"), c(99,0,5))\ntest(6001.227, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\"), c(NA,0,NA))\ntest(6001.228, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\", na.rm=TRUE), c(NA,0,2))\ntest(6001.229, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\", na.rm=TRUE, partial=TRUE), c(1,0,2))\ntest(6001.230, frollsum(adaptive=TRUE, c(1:2,NA), c(2,0,2), fill=99, algo=\"exact\", na.rm=TRUE), c(99,0,2))\ntest(6001.281, frollapply(FUN=sum, as.numeric(1:3), 0), c(0,0,0))\ntest(6001.282, frollapply(FUN=sum, as.numeric(1:3), 0, fill=99), c(0,0,0))\ntest(6001.283, frollapply(FUN=sum, c(1:2,NA_real_), 0), c(0,0,0))\ntest(6001.284, frollapply(FUN=sum, c(1:2,NA_real_), 0, na.rm=TRUE), c(0,0,0))\ntest(6001.285, frollapply(FUN=sum, c(FALSE, TRUE, TRUE), 0), c(0L,0L,0L))\ntest(6001.286, frollapply(FUN=sum, 1:3, 0), c(0L,0L,0L))\ntest(6001.2910, frollapply(FUN=sum, adaptive=TRUE, as.numeric(1:3), c(2,0,2)), c(NA,0,5))\ntest(6001.2911, frollapply(FUN=sum, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), c(2,0,2)), list(c(NA,0,5), c(NA,0,7)))\ntest(6001.2912, frollapply(FUN=sum, adaptive=TRUE, as.numeric(1:3), list(c(2,0,2), c(0,2,0))), list(c(NA,0,5), c(0,3,0)))\ntest(6001.2913, frollapply(FUN=sum, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), list(c(2,0,2), c(0,2,0))), list(c(NA,0,5), c(0,3,0), c(NA,0,7), c(0,5,0)))\ntest(6001.2914, frollapply(FUN=sum, adaptive=TRUE, c(FALSE, TRUE, TRUE), c(2,0,2)), c(NA,0L,2L))\ntest(6001.2915, frollapply(FUN=sum, adaptive=TRUE, 1:3, c(2,0,2)), c(NA,0L,5L))\ntest(6001.292, frollapply(FUN=sum, adaptive=TRUE, as.numeric(1:3), c(2,0,2), fill=99), c(99,0,5))\ntest(6001.293, frollapply(FUN=sum, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2)), c(NA,0,NA))\ntest(6001.294, frollapply(FUN=sum, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE), c(NA,0,2))\ntest(6001.295, frollapply(FUN=sum, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE, partial=TRUE), c(1,0,2))\ntest(6001.296, frollapply(FUN=sum, adaptive=TRUE, c(FALSE, TRUE, TRUE), c(2,0,2), fill=1L), c(1L,0L,2L))\ntest(6001.297, frollapply(FUN=sum, adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99L,0L,5L))\n\n---\n\n35. `as.data.table.*(x, keep.rownames=TRUE)`, where `x` is a named vector now adds names of `x` into a new column with default name `rn`. Thanks to Garrett See for FR #2356.\n\n 36. `X[Y, col:=value]` when no match exists in the join is now caught early and X is simply returned. Also a message when `datatable.verbose` is TRUE is provided. In addition, if `col` is an existing column, since no update actually takes place, the key is now retained. Thanks to Frank Erickson for suggesting, #4996.\n\n 37. New function `setDT()` takes a `list` (named and/or unnamed) or `data.frame` and changes its type by reference to `data.table`, *without any copy*. It also has a logical argument `giveNames` which is used for a list inputs. See `?setDT` examples for more. Based on [this FR on SO](https://stackoverflow.com/questions/20345022/convert-a-data-frame-to-a-data-table-without-copy/20346697#20346697).\n\n 38. `setnames(DT,\"oldname\",\"newname\")` no longer complains about any duplicated column names in `DT` so long as oldname is unique and unambiguous. Thanks to Wet Feet for highlighting [here on SO](https://stackoverflow.com/questions/20942905/ignore-safety-check-when-using-setnames).\n\n 39. `last(x)` where `length(x)=0` now returns 'x' instead of an error, #5152. Thanks to Garrett See for reporting.\n\n 40. `as.ITime.character` no longer complains when given vector input, and will accept mixed format time entries; e.g., c(\"12:00\", \"13:12:25\")\n\n 41. Key is now retained in `NA` subsets; e.g.,\n ```R\n DT = data.table(a=1:3,b=4:6,key=\"a\")\n DT[NA] # 1-row of NA now keyed by 'a'\n DT[5] # 1-row of NA now keyed by 'a'\n DT[2:4] # not keyed as before because NA (last row of result) sorts first in keyed data.table\n ```\n\n 42. Each column in the result for each group has always been recycled (if necessary) to match the longest column in that group's result. If it doesn't recycle exactly, though, it was caught gracefully as an error. Now, it is recycled, with remainder with warning.\n ```R\n DT = data.table(a=1:2,b=1:6)\n DT[, list(b,1:2), by=a] # now recycles the 1:2 with warning to length 3\n ```\n\n### BUG FIXES\n\n 1. Long outstanding (usually small) memory leak in grouping fixed, #2648. When the last group is smaller than the largest group, the difference in those sizes was not being released. Also evident in non-trivial aggregations where each group returns a different number of rows. Most users run a grouping\n query once and will never have noticed these, but anyone looping calls to grouping (such as when running in parallel, or benchmarking) may have suffered. Tests added. Thanks to many including vc273 and Y T for reporting [here](https://stackoverflow.com/questions/20349159/memory-leak-in-data-table-grouped-assignment-by-reference) and [here](https://stackoverflow.com/questions/15651515/slow-memory-leak-in-data-table-when-returning-named-lists-in-j-trying-to-reshap) on SO.\n\n 2. In long running computations where data.table is called many times repetitively the following error could sometimes occur, #2647: *\"Internal error: .internal.selfref prot is not itself an extptr\"*. Now fixed. Thanks to theEricStone, StevieP and JasonB for (difficult) reproducible examples [here](https://stackoverflow.com/questions/15342227/getting-a-random-internal-selfref-error-in-data-table-for-r).\n\n 3. If `fread` returns a data error (such as no closing quote on a quoted field) it now closes the file first rather than holding a lock open, a Windows only problem.\n Thanks to nigmastar for reporting [here](https://stackoverflow.com/questions/18597123/fread-data-table-locks-files) and Carl Witthoft for the hint. Tests added.\n\n 4. `DT[0,col:=value]` is now a helpful error rather than crash, #2754. Thanks to Ricardo Saporta for reporting. `DT[NA,col:=value]`'s error message has also been improved. Tests added.\n\n---\n\n\\item Expressions of the form \\code{DT[i, j, by]} are also optimised when\n \\code{i} is a \\emph{subset} operation and \\code{j} is any/all of the functions\n discussed above.\n}\n\nFor \\code{getOption(\"datatable.optimize\") >= 3}, additional optimisations for subsets in i are implemented on top of the optimisations already shown above. Subsetting operations are - if possible - translated into joins to make use of blazing fast binary search using indices and keys. The following queries are optimized:\n\n\\itemize{\n\n \\item Supported operators: \\code{==}, \\code{\\%in\\%}. Non-equi operators(>, <, etc.) are not supported yet because non-equi joins are slower than vector based subsets.\n \\item Queries on multiple columns are supported, if the connector is '\\code{&}', e.g. \\code{DT[x == 2 & y == 3]} is supported, but \\code{DT[x == 2 | y == 3]} is not.\n \\item Optimization will currently be turned off when doing subset when cross product of elements provided to filter on exceeds > 1e4. This most likely happens if multiple \\code{\\%in\\%}, or \\code{\\%chin\\%} queries are combined, e.g. \\code{DT[x \\%in\\% 1:100 & y \\%in\\% 1:200]} will not be optimized since \\code{100 * 200 = 2e4 > 1e4}.\n \\item Queries with multiple criteria on one column are \\emph{not} supported, e.g. \\code{DT[x == 2 & x \\%in\\% c(2,5)]} is not supported.\n \\item Queries with non-missing j are supported, e.g. \\code{DT[x == 3 & y == 5, .(new = x-y)]} or \\code{DT[x == 3 & y == 5, new := x-y]} are supported. Also extends to queries using \\code{with = FALSE}.\n \\item \"notjoin\" queries, i.e. queries that start with \\code{!}, are only supported if there are no \\code{&} connections, e.g. \\code{DT[!x==3]} is supported, but \\code{DT[!x==3 & y == 4]} is not.\n}\n\nIf in doubt, whether your query benefits from optimization, call it with the \\code{verbose = TRUE} argument. You should see \"Optimized subsetting\\ldots\".\n\n\\bold{Auto indexing:} In case a query is optimized, but no appropriate key or index is found, \\code{data.table} automatically creates an \\emph{index} on the first run. Any successive subsets on the same\ncolumn then reuse this index to \\emph{binary search} (instead of\n\\emph{vector scan}) and is therefore fast.\nAuto indexing can be switched off with the global option\n\\code{options(datatable.auto.index = FALSE)}. To switch off using existing\nindices set global option \\code{options(datatable.use.index = FALSE)}.\n}\n\\seealso{ \\code{\\link{setNumericRounding}}, \\code{\\link{getNumericRounding}} }\n\\examples{\n\\dontrun{\nold = options(datatable.optimize = Inf)\n\n# Generate a big data.table with a relatively many columns\nset.seed(1L)\nDT = lapply(1:20, function(x) sample(c(-100:100), 5e6L, TRUE))\nsetDT(DT)[, id := sample(1e5, 5e6, TRUE)]\nprint(object.size(DT), units=\"MiB\") # 400MiB, not huge, but will do\n\n# 'order' optimisation\noptions(datatable.optimize = 1L) # optimisation 'on'\nsystem.time(ans1 <- DT[order(id)])\noptions(datatable.optimize = 0L) # optimisation 'off'\nsystem.time(ans2 <- DT[order(id)])\nidentical(ans1, ans2)\n\n# optimisation of 'lapply(.SD, fun)'\noptions(datatable.optimize = 1L) # optimisation 'on'\nsystem.time(ans1 <- DT[, lapply(.SD, min), by=id])\noptions(datatable.optimize = 0L) # optimisation 'off'\nsystem.time(ans2 <- DT[, lapply(.SD, min), by=id])\nidentical(ans1, ans2)\n\n# optimisation of 'mean'\noptions(datatable.optimize = 1L) # optimisation 'on'\nsystem.time(ans1 <- DT[, lapply(.SD, mean), by=id])\nsystem.time(ans2 <- DT[, lapply(.SD, base::mean), by=id])\nidentical(ans1, ans2)\n\n# optimisation of 'c(.N, lapply(.SD, ))'\noptions(datatable.optimize = 1L) # optimisation 'on'\nsystem.time(ans1 <- DT[, c(.N, lapply(.SD, min)), by=id])\noptions(datatable.optimize = 0L) # optimisation 'off'\nsystem.time(ans2 <- DT[, c(N=.N, lapply(.SD, min)), by=id])\nidentical(ans1, ans2)\n\n---\n\n#include \"data.table.h\"\n#include \n#include // for isdigit\n\n---\n\ntest(6001.411, frollmin(1:3, 0), c(Inf,Inf,Inf), options=c(\"datatable.verbose\"=TRUE), output=\"window width of size 0\")\ntest(6001.412, frollmin(1:3, 0, fill=99), c(Inf,Inf,Inf))\ntest(6001.413, frollmin(c(1:2,NA), 0), c(Inf,Inf,Inf))\ntest(6001.414, frollmin(c(1:2,NA), 0, na.rm=TRUE), c(Inf,Inf,Inf))\ntest(6001.415, frollmin(1:3, 0, algo=\"exact\"), c(Inf,Inf,Inf), options=c(\"datatable.verbose\"=TRUE), output=\"window width of size 0\")\ntest(6001.416, frollmin(c(1:2,NA), 0, algo=\"exact\"), c(Inf,Inf,Inf))\ntest(6001.417, frollmin(c(1:2,NA), 0, algo=\"exact\", na.rm=TRUE), c(Inf,Inf,Inf))\ntest(6001.421, frollmin(adaptive=TRUE, 1:3, c(2,0,2)), c(NA,Inf,2))\ntest(6001.422, frollmin(adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,Inf,2))\ntest(6001.423, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,Inf,NA))\ntest(6001.424, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,Inf,2))\ntest(6001.425, frollmin(adaptive=TRUE, 1:3, c(2,0,2), algo=\"exact\"), c(NA,Inf,2))\ntest(6001.426, frollmin(adaptive=TRUE, 1:3, c(2,0,2), fill=99, algo=\"exact\"), c(99,Inf,2))\ntest(6001.427, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\"), c(NA,Inf,NA))\ntest(6001.428, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\", na.rm=TRUE), c(NA,Inf,2))\ntest(6001.429, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\", na.rm=TRUE, partial=TRUE), c(1,Inf,2))\ntest(6001.430, frollmin(adaptive=TRUE, c(1:2,NA), c(2,0,2), fill=99, algo=\"exact\", na.rm=TRUE), c(99,Inf,2))\ntest(6001.481, frollapply(FUN=min, 1:3, 0), c(Inf,Inf,Inf))\ntest(6001.482, frollapply(FUN=min, 1:3, 0, fill=99), c(Inf,Inf,Inf))\ntest(6001.483, frollapply(FUN=min, c(1:2,NA_real_), 0), c(Inf,Inf,Inf))\ntest(6001.484, frollapply(FUN=min, c(1:2,NA_real_), 0, na.rm=TRUE), c(Inf,Inf,Inf))\ntest(6001.4910, frollapply(FUN=min, adaptive=TRUE, as.numeric(1:3), c(2,0,2)), c(NA,Inf,2))\ntest(6001.4911, frollapply(FUN=min, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), c(2,0,2)), list(c(NA,Inf,2), c(NA,Inf,3)))\ntest(6001.4912, frollapply(FUN=min, adaptive=TRUE, as.numeric(1:3), list(c(2,0,2), c(0,2,0))), list(c(NA,Inf,2), c(Inf,1,Inf)))\ntest(6001.4913, frollapply(FUN=min, adaptive=TRUE, list(as.numeric(1:3), as.numeric(2:4)), list(c(2,0,2), c(0,2,0))), list(c(NA,Inf,2), c(Inf,1,Inf), c(NA,Inf,3), c(Inf,2,Inf)))\ntest(6001.492, frollapply(FUN=min, adaptive=TRUE, as.numeric(1:3), c(2,0,2), fill=99), c(99,Inf,2))\ntest(6001.493, frollapply(FUN=min, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2)), c(NA,Inf,NA))\ntest(6001.494, frollapply(FUN=min, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE), c(NA,Inf,2))\ntest(6001.495, frollapply(FUN=min, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE, partial=TRUE), c(1,Inf,2))\n\n---\n\ntest(6001.611, frollmedian(1:3, 0), c(NA_real_,NA_real_,NA_real_), options=c(\"datatable.verbose\"=TRUE), output=\"window width of size 0\")\ntest(6001.612, frollmedian(1:3, 0, fill=99), c(NA_real_,NA_real_,NA_real_))\ntest(6001.613, frollmedian(c(1:2,NA), 0), c(NA_real_,NA_real_,NA_real_))\ntest(6001.614, frollmedian(c(1:2,NA), 0, na.rm=TRUE), c(NA_real_,NA_real_,NA_real_))\ntest(6001.615, frollmedian(1:3, 0, algo=\"exact\"), c(NA_real_,NA_real_,NA_real_), options=c(\"datatable.verbose\"=TRUE), output=\"window width of size 0\")\ntest(6001.616, frollmedian(c(1:2,NA), 0, algo=\"exact\"), c(NA_real_,NA_real_,NA_real_))\ntest(6001.617, frollmedian(c(1:2,NA), 0, algo=\"exact\", na.rm=TRUE), c(NA_real_,NA_real_,NA_real_))\ntest(6001.621, frollmedian(adaptive=TRUE, 1:3, c(2,0,2)), c(NA,NA_real_,2.5))\ntest(6001.6211, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), has.nf=TRUE), c(NA,NA_real_,2.5), options=c(\"datatable.verbose\"=TRUE), output=\"no NAs detected, redirecting to itself using\")\ntest(6001.6212, frollmedian(adaptive=TRUE, 1:3, c(0,0,0)), c(NA_real_,NA_real_,NA_real_), options=c(\"datatable.verbose\"=TRUE), output=\"adaptive window width of size 0\")\ntest(6001.622, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,NA_real_,2.5))\ntest(6001.623, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,NA_real_,NA))\ntest(6001.624, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,NA_real_,2))\ntest(6001.625, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), algo=\"exact\"), c(NA,NA_real_,2.5))\ntest(6001.626, frollmedian(adaptive=TRUE, 1:3, c(2,0,2), fill=99, algo=\"exact\"), c(99,NA_real_,2.5))\ntest(6001.627, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\"), c(NA,NA_real_,NA))\ntest(6001.628, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\", na.rm=TRUE), c(NA,NA_real_,2))\ntest(6001.629, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), algo=\"exact\", na.rm=TRUE, partial=TRUE), c(1,NA_real_,2))\ntest(6001.630, frollmedian(adaptive=TRUE, c(1:2,NA), c(2,0,2), fill=99, algo=\"exact\", na.rm=TRUE), c(99,NA_real_,2))\ntest(6001.681, frollapply(FUN=median, c(1,2,3), 0), c(NA_real_,NA_real_,NA_real_))\ntest(6001.6811, frollapply(FUN=median, 1:3, 0), c(NA_integer_,NA_integer_,NA_integer_))\ntest(6001.682, frollapply(FUN=median, c(1,2,3), 0, fill=99), c(NA_real_,NA_real_,NA_real_))\ntest(6001.683, frollapply(FUN=median, c(1,2,NA), 0), c(NA_real_,NA_real_,NA_real_))\ntest(6001.684, frollapply(FUN=median, c(1,2,NA), 0, na.rm=TRUE), c(NA_real_,NA_real_,NA_real_))\ntest(6001.6910, frollapply(FUN=median, adaptive=TRUE, c(1,2,3), c(2,0,2)), c(NA,NA_real_,2.5))\ntest(6001.6911, frollapply(FUN=median, adaptive=TRUE, list(c(1,2,3),c(2,3,4)), c(2,0,2)), list(c(NA, NA_real_, 2.5), c(NA, NA_real_, 3.5)))\ntest(6001.6912, frollapply(FUN=median, adaptive=TRUE, c(1,2,3), list(c(2,0,2), c(0,2,0))), list(c(NA,NA_real_,2.5), c(NA_real_,1.5,NA_real_)))\ntest(6001.6913, frollapply(FUN=median, adaptive=TRUE, list(1:3,2:4), list(c(2,0,2), c(0,2,0))), list(c(NA,NA_real_,2.5), c(NA_real_,1.5,NA_real_), c(NA,NA_real_,3.5), c(NA_real_,2.5,NA_real_))) ## simplifylist\ntest(6001.692, frollapply(FUN=median, adaptive=TRUE, 1:3, c(2,0,2), fill=99), c(99,NA_real_,2.5)) ## simplifylist\ntest(6001.6921, frollapply(FUN=median, adaptive=TRUE, c(1L,2L,4L), c(2,0,2), fill=99L), c(99,NA_real_,3)) ## fill coerced to results type\ntest(6001.6922, frollapply(FUN=median, adaptive=TRUE, c(1L,2L,3L), c(2,0,2), fill=99), c(99,NA_real_,2.5)) ## simplifylist handle non-type stable output for median(1:3) median(1:2)\ntest(6001.693, frollapply(FUN=median, adaptive=TRUE, c(1:2,NA), c(2,0,2)), c(NA,NA_integer_,NA))\ntest(6001.694, frollapply(FUN=median, adaptive=TRUE, c(1:2,NA), c(2,0,2), na.rm=TRUE), c(NA,NA_integer_,2L))\ntest(6001.695, frollapply(FUN=median, adaptive=TRUE, c(1:2,NA_real_), c(2,0,2), na.rm=TRUE, partial=TRUE), c(1,NA_real_,2))\n\n---\n\nselfrefok = function(DT,verbose=getOption(\"datatable.verbose\")) {\n .Call(Cselfrefokwrapper,DT,verbose)\n}\n\ntruelength = function(x) .Call(Ctruelength,x)\n# deliberately no \"truelength<-\" method. setalloccol is the mechanism for that.\n# settruelength() no longer need (and so removed) now that data.table depends on R 2.14.0\n# which initializes tl to zero rather than leaving uninitialized.\n\nsetattr = function(x,name,value) {\n # Wrapper for setAttrib internal R function\n # Sets attribute by reference (no copy)\n # Named setattr (rather than setattrib) at R level to more closely resemble attr<-\n # And as from 1.7.8 is made exported in NAMESPACE for use in user attributes.\n # User can also call `attr<-` function directly, but that copies (maybe just when NAMED>0, which is always for data.frame, I think). See \"Confused by NAMED\" thread on r-devel 24 Nov 2011.\n # We tend to use setattr() internally in data.table.R because often we construct a data.table and it hasn't\n # got names yet. setnames() is the user interface which checks integrity and doesn't let you drop names for example.\n if (name==\"names\" && is.data.table(x) && length(attr(x, \"names\", exact=TRUE)) && !is.null(value))\n setnames(x,value)\n # Using setnames here so that truelength of names can be retained, to carry out integrity checks such as not\n # creating names longer than the number of columns of x, and to change the key, too\n # For convenience so that setattr(DT,\"names\",allnames) works as expected without requiring a switch to setnames.\n else {\n ans = .Call(Csetattrib, x, name, value)\n # If name==\"names\" and this is the first time names are assigned (e.g. in data.table()), this will be grown by setalloccol very shortly afterwards in the caller.\n if (!is.null(ans)) {\n warningf(\"Input is a length=1 logical that points to the same address as R's global value. Therefore the attribute has not been set by reference, rather on a copy. You will need to assign the result back to a variable. See issue #1281.\")\n x = ans\n }\n }\n # fix for #1142 - duplicated levels for factors\n if (name == \"levels\" && is.factor(x) && anyDuplicated(value))\n .Call(Csetlevels, x, (value <- as.character(value)), unique(value))\n invisible(x)\n}\n\n---\n\nx = 1:6/2\ntest(6004.031, frollmedian(x, 3), c(NA,NA,1,1.5,2,2.5))\ntest(6004.032, frollmedian(x, c(2L, 2L, 3L, 4L, 2L, 3L), adaptive=TRUE), c(NA, 0.75, 1, 1.25, 2.25, 2.5))\noptions(datatable.verbose=TRUE)\ntest(6004.033, frollmedian(1:3, 2), c(NA, 1.5, 2.5), output=\"frollmedianFast: running for input length\")\ntest(6004.034, frollmedian(1:3, c(2,2,2), adaptive=TRUE), c(NA, 1.5, 2.5), output=\"frolladaptivemedianExact: running in parallel\")\noptions(datatable.verbose=FALSE)\ntest(6004.035, frollmedian(rep(NA_real_, 9), 3), rep(NA_real_, 9))\ntest(6004.036, frollmedian(rep(NA_real_, 10), 3), rep(NA_real_, 10))\ntest(6004.037, frollmedian(rep(NA_real_, 10), 4), rep(NA_real_, 10))\ntest(6004.038, frollmedian(rep(NA_real_, 12), 4), rep(NA_real_, 12))\nd = as.data.table(list(1:6/2, 3:8/4))\ntest(6004.039, frollmedian(d, 3:4), list(c(NA, NA, 1, 1.5, 2, 2.5), c(NA, NA, NA, 1.25, 1.75, 2.25), c(NA, NA, 1, 1.25, 1.5, 1.75), c(NA, NA, NA, 1.125, 1.375, 1.625)))\n\nx = c(1,2,3,4,NA,6)\nk = 3\ntest(6004.101, frollmedian(x, k, na.rm=FALSE), c(NA, NA, 2, 3, NA, NA))\ntest(6004.102, frollmedian(x, k, na.rm=TRUE), c(NA, NA, 2, 3, 3.5, 5))\ntest(6004.103, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), c(NA, NA, 2, 3, NA, NA))\ntest(6004.104, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), c(NA, NA, 2, 3, 3.5, 5))\nx = c(1,2,3,4,NA,NA,6)\nk = 3\ntest(6004.105, frollmedian(x, k, na.rm=FALSE), c(NA, NA, 2, 3, NA, NA, NA))\ntest(6004.106, frollmedian(x, k, na.rm=TRUE), c(NA, NA, 2, 3, 3.5, 4, 6))\ntest(6004.107, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), c(NA, NA, 2, 3, NA, NA, NA))\ntest(6004.108, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), c(NA, NA, 2, 3, 3.5, 4, 6))\nx = c(1,2,3,4,NA,6)\nk = 4\ntest(6004.109, frollmedian(x, k, na.rm=FALSE), c(NA, NA, NA, 2.5, NA, NA))\ntest(6004.110, frollmedian(x, k, na.rm=TRUE), c(NA, NA, NA, 2.5, 3, 4))\ntest(6004.111, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), c(NA, NA, NA, 2.5, NA, NA))\ntest(6004.112, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), c(NA, NA, NA, 2.5, 3, 4))\nx = c(1,2,3,4,NA,NA,6)\nk = 4\ntest(6004.113, frollmedian(x, k, na.rm=FALSE), c(NA, NA, NA, 2.5, NA, NA, NA))\ntest(6004.114, frollmedian(x, k, na.rm=TRUE), c(NA, NA, NA, 2.5, 3, 3.5, 5))\ntest(6004.115, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), c(NA, NA, NA, 2.5, NA, NA, NA))\ntest(6004.116, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), c(NA, NA, NA, 2.5, 3, 3.5, 5))\nx = c(1,2,3,4,NA,NA,NA,NA,6)\nk = 3\ntest(6004.117, frollmedian(x, k, na.rm=FALSE), c(NA, NA, 2, 3, NA, NA, NA, NA, NA))\ntest(6004.118, frollmedian(x, k, na.rm=TRUE), c(NA, NA, 2, 3, 3.5, 4, NA, NA, 6))\ntest(6004.119, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), c(NA, NA, 2, 3, NA, NA, NA, NA, NA))\ntest(6004.120, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), c(NA, NA, 2, 3, 3.5, 4, NA, NA, 6))\nk = 4\ntest(6004.121, frollmedian(x, k, na.rm=FALSE), c(NA, NA, NA, 2.5, NA, NA, NA, NA, NA))\ntest(6004.122, frollmedian(x, k, na.rm=TRUE), c(NA, NA, NA, 2.5, 3, 3.5, 4, NA, 6))\ntest(6004.123, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), c(NA, NA, NA, 2.5, NA, NA, NA, NA, NA))\ntest(6004.124, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), c(NA, NA, NA, 2.5, 3, 3.5, 4, NA, 6))\nx = rep(NA_real_,10)\nk = 3\ntest(6004.125, frollmedian(x, k, na.rm=FALSE), rep(NA_real_,10))\ntest(6004.126, frollmedian(x, k, na.rm=TRUE), rep(NA_real_,10))\ntest(6004.127, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), rep(NA_real_,10))\ntest(6004.128, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), rep(NA_real_,10))\nk = 4\ntest(6004.129, frollmedian(x, k, na.rm=FALSE), rep(NA_real_,10))\ntest(6004.130, frollmedian(x, k, na.rm=TRUE), rep(NA_real_,10))\ntest(6004.131, frollmedian(x, k, na.rm=FALSE, algo=\"exact\"), rep(NA_real_,10))\ntest(6004.132, frollmedian(x, k, na.rm=TRUE, algo=\"exact\"), rep(NA_real_,10))\n\n---\n\n### NOTES\n\n1. `rbindlist`'s `use.names=\"check\"` now emits its message for automatic column names (`\"V[0-9]+\"`) too, [#3484](https://github.com/Rdatatable/data.table/pull/3484). See news item 5 of v1.12.2 below.\n\n2. Adding a new column by reference using `set()` on a `data.table` loaded from binary file now give a more helpful error message, [#2996](https://github.com/Rdatatable/data.table/issues/2996). Thanks to Joseph Burling for reporting.\n\n ```\n This data.table has either been loaded from disk (e.g. using readRDS()/load()) or constructed\n manually (e.g. using structure()). Please run setDT() or alloc.col() on it first (to pre-allocate\n space for new columns) before adding new columns by reference to it.\n ```\n\n3. `setorder` on a superset of a keyed `data.table`'s key now retains its key, [#3456](https://github.com/Rdatatable/data.table/issues/3456). For example, if `a` is the key of `DT`, `setorder(DT, a, -v)` will leave `DT` keyed by `a`.\n\n4. New option `options(datatable.quiet = TRUE)` turns off the package startup message, [#3489](https://github.com/Rdatatable/data.table/issues/3489). `suppressPackageStartupMessages()` continues to work too. Thanks to @leobarlach for the suggestion inspired by `options(tidyverse.quiet = TRUE)`. We don't know of a way to make a package respect the `quietly=` option of `library()` and `require()` because the `quietly=` isn't passed through for use by the package's own `.onAttach`. If you can see how to do that, please submit a patch to R.\n\n5. When loading a `data.table` from disk (e.g. with `readRDS`), best practice is to run `setDT()` on the new object to assure it is correctly allocated memory for new column pointers. Barring this, unexpected behavior can follow; for example, if you assign a new column to `DT` from a function `f`, the new columns will only be assigned within `f` and `DT` will be unchanged. The `verbose` messaging in this situation is now more helpful, [#1729](https://github.com/Rdatatable/data.table/issues/1729). Thanks @vspinu for sharing his experience to spur this.\n\n6. New vignette _Using `.SD` for Data Analysis_, a deep dive into use cases for the `.SD` variable to help illuminate this topic which we've found to be a sticking point for beginning and intermediate `data.table` users, [#3412](https://github.com/Rdatatable/data.table/issues/3412).\n\n7. Added a note to `?frank` clarifying that ranking is being done according to C sorting (i.e., like `forder`), [#2328](https://github.com/Rdatatable/data.table/issues/2328). Thanks to @cguill95 for the request.\n\n8. Historically, `dcast` and `melt` were built as enhancements to `reshape2`'s own `dcast`/`melt`. We removed dependency on `reshape2` in v1.9.6 but maintained some backward compatibility. As that package has been superseded since December 2017, we will begin to formally complete the split from `reshape2` by removing some last vestiges. In particular we now warn when redirecting to `reshape2` methods and will later error before ultimately completing the split; see [#3549](https://github.com/Rdatatable/data.table/issues/3549) and [#3633](https://github.com/Rdatatable/data.table/issues/3633). We thank the `reshape2` authors for their original inspiration for these functions, and @ProfFancyPants for testing and reporting regressions in dev which have been fixed before release.\n\n9. `DT[col]` where `col` is a column containing row numbers of itself to select, now suggests the correct syntax (`DT[(col)]` or `DT[DT$col]`), [#697](https://github.com/Rdatatable/data.table/issues/697). This expands the message introduced in [#1884](https://github.com/Rdatatable/data.table/issues/1884) for the case where `col` is type `logical` and `DT[col==TRUE]` is suggested.\n\n---\n\nRole Definition\n\nThere are two roles which are related to translations:\n\nTranslation Manager: responsible for reviewing translation-related PRs, including creating CI for checking, as in PR#6358. should be familiar with data.table internals, and will need to understand the basics of gettext() and its interface through R, including possibly through the potools package.\n\nTranslator: a project member involved with translating vignettes, messages, etc., from English to another language. Translators are encouraged to offer feedback on the quality and user-friendliness of English-language messages. They don't necessarily have to understand any data.table internals, though of course familiarity with the package will help lead to higher-quality translations.\n\nCommunication between devs and translation teams\n\nBest way to communicate with data.table devs is by creating an issue, https://github.com/Rdatatable/data.table/issues/new\n\nThere are several teams that can be mentioned in issues:\n\nCollective: https://github.com/orgs/Rdatatable/teams/translators (all translators; mention with @Rdatatable/translators)\n\nLanguage-specific: https://github.com/orgs/Rdatatable/teams/translators/teams (mention with @Rdatatable/, for e.g. @Rdatatable/French)\n\nSoftware Tools\n\nTranslating the data.table messages from zero can be easier if data.table.pot and R-data.table.pot are split in multiple, smaller files. For that, place split.R and combine.R in an empty directory created \"besides\" the data.table source code (so that, setting the working directory as that new one, ../data.table points to the source code), set MY_LOCALE to something like \"zh_CN\" or \"es\", and make sure you have installed the {potools} package and the gettext utilities. Run split.R to create the split PO files, and then translate all of them. After that, and making sure the POT files in ../data.table/po/ are current, run combine.R to create the two combined PO files, which you can then move to ../data.table/po/. Check the beginning of the PO files (the part before the first translated message) with a text editor and make any necessary adjustments. Disclaimer: the scripts were tested on Linux only, and depend on a hardcoded list of source files with no messages. They were created for the Brazilian Portuguese translation and later made more general, but were attached to the wiki before being tested by other translation teams.\n\nThe {potools} website lists applications for translating PO files, among other software packaged created for otherwise manipulating them.\n\nTODO add details about what software tools were used by the various translation teams, to make it easier to generate the translated files.\n\nTODO is it possible to join forces with base R's weblate? See discussions in https://github.com/Rdatatable/data.table/issues/6370 and (older) https://contributor.r-project.org/translations/ https://github.com/Rdatatable/data.table/pull/6199#issuecomment-2259220924\n\nPlease check https://contributor.r-project.org/translations/Conventions_for_Languages/#languages-and-contributions to see if your language already has translation guidelines in base R.\n\nAddend\n\nThe wiki doesn't permit attaching R files, so the scripts are here for now.\n\nsplit.R:\n\n#!/usr/bin/env Rscript\n\n# MY_LOCALE <- NULL # in example, \"pt_BR\", \"fr\" etc.\n\nif (!exists(\"MY_LOCALE\") | is.null(MY_LOCALE) | !is.character(MY_LOCALE) | length(MY_LOCALE) != 1) {\n stop(\"Please set MY_LOCALE in the script to something like \\\"pt_BR\\\" or \\\"es\\\"\")\n}\n\nDT_SRC <- \"../data.table\"\nif (!dir.exists(DT_SRC)) {\n stop(sprintf(\"Could not find %s. Is %s the intended working directory?\", DT_SRC, getwd))\n}\n\nlibrary(potools)\n\n---\n\n\\code{fread} is for \\emph{regular} delimited files; i.e., where every row has the same number of columns. In future, secondary separator (\\code{sep2}) may be specified \\emph{within} each column. Such columns will be read as type \\code{list} where each cell is itself a vector.\n}\n\\usage{\nfread(input, file, text, cmd, sep=\"auto\", sep2=\"auto\", dec=\"auto\", quote=\"\\\"\",\nnrows=Inf, header=\"auto\",\nna.strings=getOption(\"datatable.na.strings\",\"NA\"), # due to change to \"\"; see NEWS\nstringsAsFactors=FALSE, verbose=getOption(\"datatable.verbose\", FALSE),\nskip=\"__auto__\", select=NULL, drop=NULL, colClasses=NULL,\ninteger64=getOption(\"datatable.integer64\", \"integer64\"),\ncol.names,\ncheck.names=FALSE, encoding=\"unknown\",\nstrip.white=TRUE, fill=FALSE, blank.lines.skip=FALSE, comment.char=\"\",\nkey=NULL, index=NULL,\nshowProgress=getOption(\"datatable.showProgress\", interactive()),\ndata.table=getOption(\"datatable.fread.datatable\", TRUE),\nnThread=getDTthreads(verbose),\nlogical01=getOption(\"datatable.logical01\", FALSE),\nlogicalYN=getOption(\"datatable.logicalYN\", FALSE),\nkeepLeadingZeros = getOption(\"datatable.keepLeadingZeros\", FALSE),\nyaml=FALSE, tmpdir=tempdir(), tz=\"UTC\"\n)\n}\n\\arguments{\n \\item{input}{ A single character string. The value is inspected and deferred to either \\code{file=} (if no \\\\n present), \\code{text=} (if at least one \\\\n is present) or \\code{cmd=} (if no \\\\n is present, at least one space is present, and it isn't a file name). Exactly one of \\code{input=}, \\code{file=}, \\code{text=}, or \\code{cmd=} should be used in the same call. }\n \\item{file}{ File name in working directory, path to file (passed through \\code{\\link[base]{path.expand}} for convenience), or a URL starting http://, file://, etc. Compressed files with extension \\file{.gz} and \\file{.bz2} are supported if the \\code{R.utils} package is installed. }\n \\item{text}{ The input data itself as a character vector of one or more lines, for example as returned by \\code{readLines()}. }\n \\item{cmd}{ A shell command that pre-processes the file; e.g. \\code{fread(cmd=paste(\"grep\",word,\"filename\"))}. See Details. }\n \\item{sep}{ The separator between columns. Defaults to the character in the set \\code{[,\\\\t |;:]} that separates the sample of rows into the most number of lines with the same number of fields. Use \\code{NULL} or \\code{\"\"} to specify no separator; i.e. each line a single character column like \\code{base::readLines} does.}\n \\item{sep2}{ The separator \\emph{within} columns. A \\code{list} column will be returned where each cell is a vector of values. This is much faster using less working memory than \\code{strsplit} afterwards or similar techniques. For each column \\code{sep2} can be different and is the first character in the same set above [\\code{,\\\\t |;}], other than \\code{sep}, that exists inside each field outside quoted regions in the sample. NB: \\code{sep2} is not yet implemented. }\n \\item{nrows}{ The maximum number of rows to read. Unlike \\code{read.table}, you do not need to set this to an estimate of the number of rows in the file for better speed because that is already automatically determined by \\code{fread} almost instantly using the large sample of lines. \\code{nrows=0} returns the column names and typed empty columns determined by the large sample; useful for a dry run of a large file or to quickly check format consistency of a set of files before starting to read any of them. }\n \\item{header}{ Does the first data line contain column names? Defaults according to whether every non-empty field on the first data line is type character. If so, or TRUE is supplied, any empty column names are given a default name. }", "answer": "`data.table` is an R package that provides an enhanced version of the standard `data.frame`. It is designed for high-performance data manipulation, focusing on speed and memory efficiency, particularly for large datasets (e.g., 100GB in RAM or up to two billion rows).\n\n### Core Principles\nThe project is guided by several key design decisions:\n* **Efficiency:** It uses low-level parallelism (OpenMP) to speed up common operations and employs reference semantics to modify data without making unnecessary copies.\n* **Concise Syntax:** The syntax is designed to minimize redundancy, making code faster to type and easier to read.\n* **Minimal Dependencies:** It has no external dependencies other than base R, simplifying production maintenance.\n* **Stability:** There is a strong preference for user-friendly back-compatibility and support for older versions of R (currently back to R 3.5.0).\n\n### General Syntax: `DT[i, j, by]`\nThe syntax is structured like a query, analogous to SQL:\n* **`i`:** Where or Order By (filtering or reordering rows).\n* **`j`:** Select or Update (computing on columns).\n* **`by`:** Group By (aggregating data).\n\n**How to read it:** \"Take `DT`, subset/reorder rows using `i`, then calculate `j`, grouped by `by`.\"\n\n### Key Features\n* **Fast I/O:** Includes `fread` for rapid file reading and `fwrite` for parallelized file writing.\n* **Reference Semantics:** The `:=` operator and `set*` functions (like `setkey`, `setorder`, `setnames`) modify data \"by reference,\" meaning they update the object in place without copying it in memory.\n* **Advanced Joins:** Supports ordered joins (rolling forwards, backwards, or nearest), non-equi joins (using operators like `>`, `<`), and overlapping range joins.\n* **GForce Optimization:** Internally optimizes common grouped operations (like `sum`, `mean`, `min`, `max`) to run much faster than standard R equivalents.\n* **Reshaping:** High-performance versions of `melt` (wide-to-long) and `dcast` (long-to-wide).\n\n### Community and Ecosystem\n`data.table` is one of the most-starred R packages on GitHub and is used as a dependency by hundreds of CRAN and Bioconductor packages. It is maintained by a core team and a community of contributors, with governance focused on maintaining a self-sustaining ecosystem for efficient big data analysis.\n\nFor more details, you can view the package vignettes by typing `vignette(package=\"data.table\")` in your R console or use `?data.table` to see the primary documentation and arguments.", "source_count": 100, "source_metadata": [{"project": "data.table", "id": "e4647882f8584c6da6aca1041fabe80a", "source": "data.table.wiki"}, {"id": "5888c9a5cbd944759795b8646586ee51", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table", "file_path": "README.md", "file_name": "README.md", "id": "3c4fe1a2582b4ed59bb52ebc1b9b65a8", "project": "data.table"}, {"id": "0ca33a9d7ad346e09dda76d4bea9e861", "file_name": "datatable-sd-usage.Rmd", "source": "data.table", "project": "data.table", "file_path": "vignettes\\datatable-sd-usage.Rmd"}, {"file_name": "datatable-keys-fast-subset.Rmd", "id": "692bc7fd21f24ee38e448a94b28ebda1", "file_path": "vignettes\\datatable-keys-fast-subset.Rmd", "source": "data.table", "project": "data.table"}, {"id": "6932435f68c848d1b616e5695cc39dda", "project": "data.table", "source": "data.table.wiki"}, {"file_path": "vignettes\\fr\\datatable-importing.Rmd", "id": "3d8247b228794497a2c33b0c496067ea", "file_name": "datatable-importing.Rmd", "source": "data.table", "project": "data.table"}, {"id": "96dd04b8ec0442dbbd4b9dc31970e012", "source": "data.table", "project": "data.table", "file_name": "Seal_of_Approval.md", "file_path": "Seal_of_Approval.md"}, {"id": "e85dca8179784f35b8f1d1f1fa96974a", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table", "file_name": "datatable-faq.Rmd", "id": "ee3c8d98a7464061a751cdeed58cd3f5", "file_path": "vignettes\\es\\datatable-faq.Rmd", "project": "data.table"}, {"file_path": "R\\print.data.table.R", "file_name": "print.data.table.R", "id": "8b7840063f8d4caa9e786febd5cdd7bd", "source": "data.table", "project": "data.table"}, {"file_name": "datatable-importing.Rmd", "id": "afea17444efa4ca9b70a668c1a8d6349", "file_path": "vignettes\\fr\\datatable-importing.Rmd", "source": "data.table", "project": "data.table"}, {"project": "data.table", "id": "d0848409b42948d1a9f2ab34e5bb9096", "file_name": "froll.Rd", "source": "data.table", "file_path": "man\\froll.Rd"}, {"project": "data.table", "file_name": "CONTRIBUTING.md", "file_path": ".github\\CONTRIBUTING.md", "id": "4fab07e5a1aa417db93d1a647cb8e606", "source": "data.table"}, {"id": "e086a585719a425c955026555e249a3c", "file_path": "NEWS.0.md", "project": "data.table", "file_name": "NEWS.0.md", "source": "data.table"}, {"source": "data.table", "project": "data.table", "file_path": "vignettes\\es\\datatable-importing.Rmd", "id": "62cc00e2a4784b19963dcbf21303756d", "file_name": "datatable-importing.Rmd"}, {"source": "data.table.wiki", "id": "0265060481924c469c427ff4c5ba5757", "project": "data.table"}, {"file_name": "datatable-faq.Rmd", "id": "d605a34ddf8144bd85b9d02f2bc5dd4e", "source": "data.table", "file_path": "vignettes\\fr\\datatable-faq.Rmd", "project": "data.table"}, {"source": "data.table", "id": "7d082cfc6ca445adbd65f48162acd502", "file_name": "datatable-intro.Rmd", "project": "data.table", "file_path": "vignettes\\fr\\datatable-intro.Rmd"}, {"id": "dae2a8ad93764d51bf8859b8cab1334e", "project": "data.table", "file_path": "NEWS.0.md", "file_name": "NEWS.0.md", "source": "data.table"}, {"source": "data.table", "id": "c5ab43047d0d422ba5c2df6445a21e21", "project": "data.table", "file_name": "DESCRIPTION", "file_path": "DESCRIPTION"}, {"source": "data.table", "id": "0e2d7abd759a44bdb3f790a2406b8e5a", "file_path": "README.md", "file_name": "README.md", "project": "data.table"}, {"id": "2b4dfd575daa49329c5d1d23412e93a9", "project": "data.table", "source": "data.table", "file_name": "GOVERNANCE.md", "file_path": "GOVERNANCE.md"}, {"file_path": "vignettes\\fr\\datatable-faq.Rmd", "id": "ea975b8f9def4ff080d65f9b1fa88a48", "project": "data.table", "file_name": "datatable-faq.Rmd", "source": "data.table"}, {"project": "data.table", "id": "29e043e15c9d4120b442b29ef94ad07a", "file_path": "src\\coalesce.c", "source": "data.table", "file_name": "coalesce.c"}, {"source": "data.table", "file_name": "cj.c", "id": "446cfa5a99104b0294e30e25dd2232d2", "file_path": "src\\cj.c", "project": "data.table"}, {"file_name": "datatable-intro.Rmd", "source": "data.table", "id": "272206e706434c71a3d9c24508052785", "project": "data.table", "file_path": "vignettes\\ru\\datatable-intro.Rmd"}, {"file_path": "vignettes\\fr\\datatable-faq.Rmd", "file_name": "datatable-faq.Rmd", "id": "7845c3e8bf054557938399888ebf6e25", "project": "data.table", "source": "data.table"}, {"id": "1708719cf80e40c994394abee5c19834", "file_name": "datatable-importing.Rmd", "project": "data.table", "source": "data.table", "file_path": "vignettes\\es\\datatable-importing.Rmd"}, {"file_name": "NEWS.0.md", "file_path": "NEWS.0.md", "project": "data.table", "id": "28086cfb48804963bec9a6a6a8143733", "source": "data.table"}, {"project": "data.table", "file_path": ".ci\\atime\\tests.R", "source": "data.table", "id": "5800f811b30d4c34b9a96fc9ec37dbb4", "file_name": "tests.R"}, {"id": "8764c4f90fe44d76bca0481224b6fdda", "source": "data.table.wiki", "project": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "fa8c789ab51d46d8a1af2ef2f526233f"}, {"id": "6d67629570c241e8860c6e94e01c1dd8", "project": "data.table", "file_path": "vignettes\\es\\datatable-intro.Rmd", "file_name": "datatable-intro.Rmd", "source": "data.table"}, {"id": "2959c644c31f4a2c8d2dd4210648fe73", "project": "data.table", "file_path": "NEWS.1.md", "file_name": "NEWS.1.md", "source": "data.table"}, {"id": "77beaf30ea0c4e68aa40a34ec8592d3e", "file_name": "tests.Rraw", "file_path": "inst\\tests\\tests.Rraw", "source": "data.table", "project": "data.table"}, {"file_path": "vignettes\\fr\\datatable-importing.Rmd", "file_name": "datatable-importing.Rmd", "source": "data.table", "id": "d6b011e6d2a34013a9fb3508026373d3", "project": "data.table"}, {"project": "data.table", "file_path": ".github\\PULL_REQUEST_TEMPLATE.md", "file_name": "PULL_REQUEST_TEMPLATE.md", "id": "4f7cf3d6d47f49fd8f7c095ac9bb67d7", "source": "data.table"}, {"source": "data.table", "id": "7963a37b46104633a477272aaf769caa", "project": "data.table", "file_name": "NEWS.1.md", "file_path": "NEWS.1.md"}, {"id": "c3f8507d46b54e36bc81f29bd2686639", "source": "data.table", "file_name": "NEWS.0.md", "file_path": "NEWS.0.md", "project": "data.table"}, {"project": "data.table", "id": "e174ddee472442d7b7ec4372385154d5", "source": "data.table", "file_path": "NEWS.1.md", "file_name": "NEWS.1.md"}, {"id": "64f5109f50f4434dbf105465c7c7993f", "project": "data.table", "source": "data.table.wiki"}, {"source": "data.table", "file_path": "src\\bmerge.c", "file_name": "bmerge.c", "id": "0ce1a786131a4c12994655909ca8a7c4", "project": "data.table"}, {"file_name": "data.table.Rd", "project": "data.table", "file_path": "man\\data.table.Rd", "source": "data.table", "id": "e7b23a2af95e44b7a2e88ec792de0fcf"}, {"id": "1539deb666344c98bf744ec87d97ed02", "file_path": "NEWS.md", "source": "data.table", "project": "data.table", "file_name": "NEWS.md"}, {"file_path": "po\\fr.po", "project": "data.table", "source": "data.table", "id": "b3bd3e024fac4ab7bc96756e20908b3a", "file_name": "fr.po"}, {"id": "32e8c1a9870a47b7900cfaae98ce748b", "project": "data.table", "source": "data.table.wiki"}, {"file_name": "foverlaps.R", "id": "d6b39b76762a47d6aff8d12c94488465", "source": "data.table", "file_path": "R\\foverlaps.R", "project": "data.table"}, {"file_path": "NEWS.0.md", "file_name": "NEWS.0.md", "source": "data.table", "id": "066c2f1e742d4436b4a69f442a0c18b6", "project": "data.table"}, {"source": "data.table", "id": "d4477703b1f24664b6de82453a94420a", "file_name": "datatable-importing.Rmd", "file_path": "vignettes\\es\\datatable-importing.Rmd", "project": "data.table"}, {"file_path": "vignettes\\es\\datatable-faq.Rmd", "file_name": "datatable-faq.Rmd", "project": "data.table", "source": "data.table", "id": "1937aea5e2164c1e837328824c65efd0"}, {"source": "data.table", "file_path": "vignettes\\es\\datatable-faq.Rmd", "file_name": "datatable-faq.Rmd", "project": "data.table", "id": "ad164acdf5cf48daa60dcf1f2c6be368"}, {"project": "data.table", "source": "data.table", "file_name": "R-fr.po", "file_path": "po\\R-fr.po", "id": "2aec2a56ff82481491a3fbae58f063e1"}, {"file_name": "special-symbols.Rd", "project": "data.table", "file_path": "man\\special-symbols.Rd", "id": "ddba1b035dde4dd9bb5234815af1c438", "source": "data.table"}, {"file_path": "man\\IDateTime.Rd", "file_name": "IDateTime.Rd", "id": "e5f9a3c717b14e29972bf98a0f18bb02", "project": "data.table", "source": "data.table"}, {"file_name": "setkey.Rd", "project": "data.table", "file_path": "man\\setkey.Rd", "source": "data.table", "id": "25a5ba8df599433d8085fd74b70dbfa6"}, {"source": "data.table", "id": "eaffbc148709468bb4af60cab06bd723", "file_path": "man\\data.table-options.Rd", "file_name": "data.table-options.Rd", "project": "data.table"}, {"id": "182be49a1d4c41fea09b321330087992", "file_path": "NEWS.0.md", "file_name": "NEWS.0.md", "project": "data.table", "source": "data.table"}, {"file_path": "inst\\tests\\mergelist.Rraw", "project": "data.table", "id": "f4f9322e6b054e7aa3c4d699f564ca19", "source": "data.table", "file_name": "mergelist.Rraw"}, {"file_path": "NEWS.1.md", "file_name": "NEWS.1.md", "id": "82dd97f50dae4e1e84ae64408edf569a", "project": "data.table", "source": "data.table"}, {"file_path": "vignettes\\es\\datatable-benchmarking.Rmd", "project": "data.table", "id": "d14cac8678e84af385bd2f2c895f9f1e", "source": "data.table", "file_name": "datatable-benchmarking.Rmd"}, {"project": "data.table", "id": "067b8e1134cd444ea18cac86efc673fc", "source": "data.table", "file_path": "vignettes\\fr\\datatable-benchmarking.Rmd", "file_name": "datatable-benchmarking.Rmd"}, {"project": "data.table", "id": "9d3c370b49c94db0a8f1d38f9c04e012", "source": "data.table", "file_path": "NEWS.md", "file_name": "NEWS.md"}, {"file_path": "man\\datatable-optimize.Rd", "project": "data.table", "file_name": "datatable-optimize.Rd", "source": "data.table", "id": "521f5adbb4134dc09b6b3176bff3396b"}, {"project": "data.table", "file_path": "NEWS.0.md", "file_name": "NEWS.0.md", "id": "35f4df56461a46978cfab9a3eb8d0d86", "source": "data.table"}, {"project": "data.table", "source": "data.table", "file_path": "NEWS.0.md", "file_name": "NEWS.0.md", "id": "82c10685280f4eb8b3ec3ce37e3ca643"}, {"project": "data.table", "file_name": "rowwiseDT.Rd", "file_path": "man\\rowwiseDT.Rd", "id": "43827dee1503490fb4de49f127522139", "source": "data.table"}, {"source": "data.table", "file_name": "NEWS.0.md", "id": "8a48be0be63c4358826c6825cdc996ac", "project": "data.table", "file_path": "NEWS.0.md"}, {"id": "a47653a44e804ef990bb390726a1f704", "source": "data.table", "project": "data.table", "file_name": "setkey.Rd", "file_path": "man\\setkey.Rd"}, {"file_name": "NEWS.0.md", "project": "data.table", "file_path": "NEWS.0.md", "source": "data.table", "id": "96549ba05bfb4210a263993adabde91e"}, {"id": "b5e5fd6fc953467eaab044dca55c8c58", "file_path": "po\\pt_BR.po", "source": "data.table", "project": "data.table", "file_name": "pt_BR.po"}, {"file_path": "vignettes\\es\\datatable-faq.Rmd", "file_name": "datatable-faq.Rmd", "source": "data.table", "project": "data.table", "id": "50a6a8482e224b4bbe80ab094953af08"}, {"file_path": "man\\test.Rd", "project": "data.table", "file_name": "test.Rd", "id": "63c5d5c74ade42cfb2d2fdbeb04906e1", "source": "data.table"}, {"id": "f257cef0513b4a94a5b8397fb3d11e5a", "file_path": "po\\R-ru.po", "file_name": "R-ru.po", "project": "data.table", "source": "data.table"}, {"source": "data.table", "file_path": "man\\data.table.Rd", "file_name": "data.table.Rd", "id": "b13d53994c0d4b86ac2d726d65efc14d", "project": "data.table"}, {"file_name": "nafill.Rraw", "file_path": "inst\\tests\\nafill.Rraw", "id": "1ccaa81080944aa19cec384631ad2599", "source": "data.table", "project": "data.table"}, {"file_path": "vignettes\\es\\datatable-keys-fast-subset.Rmd", "id": "0221a38148da47108cea3bf5a647ed3d", "project": "data.table", "file_name": "datatable-keys-fast-subset.Rmd", "source": "data.table"}, {"source": "data.table.wiki", "project": "data.table", "id": "54ed1da73e8d4898adfa74986448ec1d"}, {"source": "data.table", "id": "30dc63e491eb42c5bcd6f74f065c01b5", "file_name": "datatable-importing.Rmd", "file_path": "vignettes\\ru\\datatable-importing.Rmd", "project": "data.table"}, {"id": "d3d5f9fb00ad4b0ca100dac77142b18f", "file_name": "R-zh_CN.po", "source": "data.table", "file_path": "po\\R-zh_CN.po", "project": "data.table"}, {"project": "data.table", "file_name": "NEWS.md", "file_path": "NEWS.md", "source": "data.table", "id": "c73b4426147a445687fd108593a26453"}, {"file_path": "inst\\tests\\tests.Rraw", "source": "data.table", "id": "364a4fa3d6484952ba58f19e3fc212bd", "file_name": "tests.Rraw", "project": "data.table"}, {"id": "d4f33ac82d064390b60c8546e35198ba", "file_name": "setkey.R", "project": "data.table", "source": "data.table", "file_path": "R\\setkey.R"}, {"project": "data.table", "source": "data.table", "file_path": "man\\tables.Rd", "file_name": "tables.Rd", "id": "c7963258d5dd4678bb4fea2138fec5ca"}, {"id": "890a502b54c14bef8dae6116fecf9b8a", "file_name": "R-pt_BR.po", "file_path": "po\\R-pt_BR.po", "project": "data.table", "source": "data.table"}, {"file_name": "datatable-intro.Rmd", "project": "data.table", "source": "data.table", "file_path": "vignettes\\es\\datatable-intro.Rmd", "id": "90b8e30bf4f2402ab17d4e1f18c5c217"}, {"file_path": "inst\\tests\\tests.Rraw", "file_name": "tests.Rraw", "project": "data.table", "source": "data.table", "id": "cebd18ca47c54861b75a682f17caf511"}, {"id": "37a1d0d5aa554c9885e8a3ae2dda934f", "file_name": "fread.h", "project": "data.table", "source": "data.table", "file_path": "src\\fread.h"}, {"file_name": "R-zh_CN.po", "source": "data.table", "id": "4f05ae4a5cf34395b8be1fe0d7165701", "project": "data.table", "file_path": "po\\R-zh_CN.po"}, {"id": "120d33f1857e416c8c1c5550a50e3a5d", "file_path": "inst\\tests\\froll.Rraw", "project": "data.table", "source": "data.table", "file_name": "froll.Rraw"}, {"id": "876ad4e0aa8f4416b882e325379cae57", "project": "data.table", "file_path": "NEWS.0.md", "source": "data.table", "file_name": "NEWS.0.md"}, {"file_path": "man\\datatable-optimize.Rd", "id": "6af5e9cf6606453f88f73049c23d2a05", "project": "data.table", "file_name": "datatable-optimize.Rd", "source": "data.table"}, {"file_path": "src\\rbindlist.c", "project": "data.table", "file_name": "rbindlist.c", "id": "67acc565438749269472dd611bd6bc7b", "source": "data.table"}, {"project": "data.table", "id": "265f35fbafb54a4c9c9148902cdc384b", "file_name": "froll.Rraw", "file_path": "inst\\tests\\froll.Rraw", "source": "data.table"}, {"file_name": "froll.Rraw", "source": "data.table", "project": "data.table", "id": "997e02ac34fe4653b54adef30f814540", "file_path": "inst\\tests\\froll.Rraw"}, {"id": "3b90a8ea608d41338e48a21884c57c09", "project": "data.table", "file_path": "R\\data.table.R", "source": "data.table", "file_name": "data.table.R"}, {"project": "data.table", "file_path": "inst\\tests\\froll.Rraw", "source": "data.table", "file_name": "froll.Rraw", "id": "56e2ff8ea4a343de9b9907de00b8f578"}, {"source": "data.table", "project": "data.table", "file_path": "NEWS.1.md", "id": "2ba9f017369b41a2836e0bb0a22c76af", "file_name": "NEWS.1.md"}, {"source": "data.table.wiki", "project": "data.table", "id": "024d1d9c793f45b3916973255855ce45"}, {"project": "data.table", "id": "78846d22211d4d7883a277d3214e5fd0", "file_name": "fread.Rd", "file_path": "man\\fread.Rd", "source": "data.table"}]} diff --git a/systems/docgpt/.docker/postgres/docker-entrypoint-initdb.d/create-vector-extension.sh b/systems/openrag/.docker/postgres/docker-entrypoint-initdb.d/create-vector-extension.sh similarity index 100% rename from systems/docgpt/.docker/postgres/docker-entrypoint-initdb.d/create-vector-extension.sh rename to systems/openrag/.docker/postgres/docker-entrypoint-initdb.d/create-vector-extension.sh diff --git a/systems/openrag/.env.test b/systems/openrag/.env.test new file mode 100644 index 0000000..bbe90aa --- /dev/null +++ b/systems/openrag/.env.test @@ -0,0 +1,20 @@ +# Gemini API key (or set GOOGLE_API_KEY) +AI_GEMINI_MODEL=gemini-3-flash-preview +AI_GEMINI_APIKEY=REPLACE_ME + +# Discord bot token (use a dedicated test bot token) +APP_DISCORD_TOKEN=REPLACE_ME + + +# Force pgvector backend for isolated test database runs +STORAGE_VECTOR_BACKEND=pgvector + +# PostgreSQL test database (docker-compose.test.yml) +# Format: postgresql+psycopg://USER:PASSWORD@HOST:PORT/DATABASE +STORAGE_VECTOR_URL=postgresql+psycopg://root:example@localhost:55432/openrag_test + +# MongoDB test database (docker-compose.test.yml) +STORAGE_MEMORY_URL=mongodb://root:example@localhost:55432/openrag_test + +# Optional +LOG_LEVEL=INFO diff --git a/systems/docgpt/.env.test.example b/systems/openrag/.env.test.example similarity index 84% rename from systems/docgpt/.env.test.example rename to systems/openrag/.env.test.example index 360e6b0..6903ffe 100644 --- a/systems/docgpt/.env.test.example +++ b/systems/openrag/.env.test.example @@ -9,10 +9,10 @@ STORAGE_VECTOR_BACKEND=pgvector # PostgreSQL test database (docker-compose.test.yml) # Format: postgresql+psycopg://USER:PASSWORD@HOST:PORT/DATABASE -STORAGE_VECTOR_URL=postgresql+psycopg://root:example@localhost:55432/docgpt_test +STORAGE_VECTOR_URL=postgresql+psycopg://root:example@localhost:55432/openrag_test # MongoDB test database (docker-compose.test.yml) -STORAGE_MEMORY_URL=mongodb://root:example@localhost:27018/docgpt_test +STORAGE_MEMORY_URL=mongodb://root:example@localhost:27018/openrag_test # Optional LOG_LEVEL=INFO diff --git a/systems/docgpt/.gitignore b/systems/openrag/.gitignore similarity index 100% rename from systems/docgpt/.gitignore rename to systems/openrag/.gitignore diff --git a/systems/docgpt/README.md b/systems/openrag/README.md similarity index 97% rename from systems/docgpt/README.md rename to systems/openrag/README.md index cbc597f..665d91e 100644 --- a/systems/docgpt/README.md +++ b/systems/openrag/README.md @@ -1,4 +1,4 @@ -# DocGPT (WIP) +# OpenRAG (WIP) ## Useful commands @@ -31,7 +31,7 @@ STORAGE_LOGS_URL=postgresql://root:example@localhost:5432/postgres - Configure the RAG name and whether to log the raw, non-RAG LLM answer via: ```env -ASSISTANT_RAG_NAME=docgpt +ASSISTANT_RAG_NAME=openrag ASSISTANT_LOG_RAW_LLM_ANSWER=false ``` @@ -41,7 +41,7 @@ ASSISTANT_LOG_RAW_LLM_ANSWER=false from pathlib import Path from src.logging.discord_logger import DiscordInteractionLogger -logger = DiscordInteractionLogger(dsn="postgresql://root:example@localhost:5432/postgres", rag_name="docgpt") +logger = DiscordInteractionLogger(dsn="postgresql://root:example@localhost:5432/postgres", rag_name="openrag") logger.export_csv(Path("discord_interactions.csv")) ``` diff --git a/systems/docgpt/config.yml b/systems/openrag/config.yml similarity index 96% rename from systems/docgpt/config.yml rename to systems/openrag/config.yml index 15ed70c..033791a 100644 --- a/systems/docgpt/config.yml +++ b/systems/openrag/config.yml @@ -25,7 +25,7 @@ assistant: tokens_limit: ${ASSISTANT_TOKENS_LIMIT:2000} score_threshold: ${ASSISTANT_SCORE_THRESHOLD:null} distance_threshold: ${DISTANCE_THRESHOLD:null} - rag_name: ${ASSISTANT_RAG_NAME:docgpt} + rag_name: ${ASSISTANT_RAG_NAME:openrag} log_raw_llm_answer: ${ASSISTANT_LOG_RAW_LLM_ANSWER:false} storage: diff --git a/systems/docgpt/discord_interactions.csv b/systems/openrag/discord_interactions.csv similarity index 100% rename from systems/docgpt/discord_interactions.csv rename to systems/openrag/discord_interactions.csv diff --git a/systems/docgpt/docker-compose.test.yml b/systems/openrag/docker-compose.test.yml similarity index 72% rename from systems/docgpt/docker-compose.test.yml rename to systems/openrag/docker-compose.test.yml index fe3794f..7daa832 100644 --- a/systems/docgpt/docker-compose.test.yml +++ b/systems/openrag/docker-compose.test.yml @@ -10,9 +10,9 @@ services: environment: - POSTGRES_USER=root - POSTGRES_PASSWORD=example - - POSTGRES_DB=docgpt_test + - POSTGRES_DB=openrag_test volumes: - - docgpt_test_postgres_data:/var/lib/postgresql/data + - openrag_test_postgres_data:/var/lib/postgresql/data memory_storage_test: image: mongo @@ -24,8 +24,8 @@ services: MONGO_INITDB_ROOT_USERNAME: root MONGO_INITDB_ROOT_PASSWORD: example volumes: - - docgpt_test_mongo_data:/data/db + - openrag_test_mongo_data:/data/db volumes: - docgpt_test_postgres_data: - docgpt_test_mongo_data: + openrag_test_postgres_data: + openrag_test_mongo_data: diff --git a/systems/docgpt/docker-compose.yml b/systems/openrag/docker-compose.yml similarity index 100% rename from systems/docgpt/docker-compose.yml rename to systems/openrag/docker-compose.yml diff --git a/systems/docgpt/main.py b/systems/openrag/main.py similarity index 100% rename from systems/docgpt/main.py rename to systems/openrag/main.py diff --git a/systems/docgpt/pandoc-3.9-windows-x86_64.msi b/systems/openrag/pandoc-3.9-windows-x86_64.msi similarity index 100% rename from systems/docgpt/pandoc-3.9-windows-x86_64.msi rename to systems/openrag/pandoc-3.9-windows-x86_64.msi diff --git a/systems/docgpt/pyproject.toml b/systems/openrag/pyproject.toml similarity index 98% rename from systems/docgpt/pyproject.toml rename to systems/openrag/pyproject.toml index ee5154b..9dd6a3b 100644 --- a/systems/docgpt/pyproject.toml +++ b/systems/openrag/pyproject.toml @@ -1,5 +1,5 @@ [project] -name = "docgpt" +name = "openrag" version = "0.1.0" description = "" readme = "README.md" diff --git a/systems/docgpt/run-test-bot.sh b/systems/openrag/run-test-bot.sh similarity index 100% rename from systems/docgpt/run-test-bot.sh rename to systems/openrag/run-test-bot.sh diff --git a/systems/docgpt/src/adapters/__init__.py b/systems/openrag/src/adapters/__init__.py similarity index 100% rename from systems/docgpt/src/adapters/__init__.py rename to systems/openrag/src/adapters/__init__.py diff --git a/systems/docgpt/src/adapters/assistant.py b/systems/openrag/src/adapters/assistant.py similarity index 100% rename from systems/docgpt/src/adapters/assistant.py rename to systems/openrag/src/adapters/assistant.py diff --git a/systems/docgpt/src/adapters/content/__init__.py b/systems/openrag/src/adapters/content/__init__.py similarity index 100% rename from systems/docgpt/src/adapters/content/__init__.py rename to systems/openrag/src/adapters/content/__init__.py diff --git a/systems/docgpt/src/adapters/content/converter.py b/systems/openrag/src/adapters/content/converter.py similarity index 100% rename from systems/docgpt/src/adapters/content/converter.py rename to systems/openrag/src/adapters/content/converter.py diff --git a/systems/docgpt/src/adapters/content/git/__init__.py b/systems/openrag/src/adapters/content/git/__init__.py similarity index 100% rename from systems/docgpt/src/adapters/content/git/__init__.py rename to systems/openrag/src/adapters/content/git/__init__.py diff --git a/systems/docgpt/src/adapters/content/git/code.py b/systems/openrag/src/adapters/content/git/code.py similarity index 100% rename from systems/docgpt/src/adapters/content/git/code.py rename to systems/openrag/src/adapters/content/git/code.py diff --git a/systems/docgpt/src/adapters/content/git/wiki.py b/systems/openrag/src/adapters/content/git/wiki.py similarity index 100% rename from systems/docgpt/src/adapters/content/git/wiki.py rename to systems/openrag/src/adapters/content/git/wiki.py diff --git a/systems/docgpt/src/adapters/content/text_splitter.py b/systems/openrag/src/adapters/content/text_splitter.py similarity index 100% rename from systems/docgpt/src/adapters/content/text_splitter.py rename to systems/openrag/src/adapters/content/text_splitter.py diff --git a/systems/docgpt/src/adapters/content/web.py b/systems/openrag/src/adapters/content/web.py similarity index 100% rename from systems/docgpt/src/adapters/content/web.py rename to systems/openrag/src/adapters/content/web.py diff --git a/systems/docgpt/src/app/__init__.py b/systems/openrag/src/app/__init__.py similarity index 100% rename from systems/docgpt/src/app/__init__.py rename to systems/openrag/src/app/__init__.py diff --git a/systems/docgpt/src/app/api/__init__.py b/systems/openrag/src/app/api/__init__.py similarity index 100% rename from systems/docgpt/src/app/api/__init__.py rename to systems/openrag/src/app/api/__init__.py diff --git a/systems/docgpt/src/app/api/create_app.py b/systems/openrag/src/app/api/create_app.py similarity index 100% rename from systems/docgpt/src/app/api/create_app.py rename to systems/openrag/src/app/api/create_app.py diff --git a/systems/docgpt/src/app/api/deps/__init__.py b/systems/openrag/src/app/api/deps/__init__.py similarity index 100% rename from systems/docgpt/src/app/api/deps/__init__.py rename to systems/openrag/src/app/api/deps/__init__.py diff --git a/systems/docgpt/src/app/api/health.py b/systems/openrag/src/app/api/health.py similarity index 100% rename from systems/docgpt/src/app/api/health.py rename to systems/openrag/src/app/api/health.py diff --git a/systems/docgpt/src/app/api/runners.py b/systems/openrag/src/app/api/runners.py similarity index 100% rename from systems/docgpt/src/app/api/runners.py rename to systems/openrag/src/app/api/runners.py diff --git a/systems/docgpt/src/app/api/v1/__init__.py b/systems/openrag/src/app/api/v1/__init__.py similarity index 100% rename from systems/docgpt/src/app/api/v1/__init__.py rename to systems/openrag/src/app/api/v1/__init__.py diff --git a/systems/docgpt/src/app/api/v1/endpoints/__init__.py b/systems/openrag/src/app/api/v1/endpoints/__init__.py similarity index 100% rename from systems/docgpt/src/app/api/v1/endpoints/__init__.py rename to systems/openrag/src/app/api/v1/endpoints/__init__.py diff --git a/systems/docgpt/src/app/api/v1/endpoints/assistant.py b/systems/openrag/src/app/api/v1/endpoints/assistant.py similarity index 100% rename from systems/docgpt/src/app/api/v1/endpoints/assistant.py rename to systems/openrag/src/app/api/v1/endpoints/assistant.py diff --git a/systems/docgpt/src/app/discord.py b/systems/openrag/src/app/discord.py similarity index 100% rename from systems/docgpt/src/app/discord.py rename to systems/openrag/src/app/discord.py diff --git a/systems/docgpt/src/core/__init__.py b/systems/openrag/src/core/__init__.py similarity index 100% rename from systems/docgpt/src/core/__init__.py rename to systems/openrag/src/core/__init__.py diff --git a/systems/docgpt/src/core/containers.py b/systems/openrag/src/core/containers.py similarity index 99% rename from systems/docgpt/src/core/containers.py rename to systems/openrag/src/core/containers.py index 6edcc94..a9e2df5 100644 --- a/systems/docgpt/src/core/containers.py +++ b/systems/openrag/src/core/containers.py @@ -75,7 +75,7 @@ class StorageAdapters(containers.DeclarativeContainer): PGVector, connection=config.vector.url, embeddings=ai.embeddings, - collection_name="docgpt_embeddings", + collection_name="openrag_embeddings", use_jsonb=True, ) diff --git a/systems/docgpt/src/core/interaction_logger.py b/systems/openrag/src/core/interaction_logger.py similarity index 99% rename from systems/docgpt/src/core/interaction_logger.py rename to systems/openrag/src/core/interaction_logger.py index b783e79..cf0832d 100644 --- a/systems/docgpt/src/core/interaction_logger.py +++ b/systems/openrag/src/core/interaction_logger.py @@ -1,5 +1,5 @@ """ -Interaction Logger for DocGPT +Interaction Logger for OpenRAG Automatically logs every RAG interaction (question, retrieved context, answer) to CSV and JSONL files. Each row is appended immediately after the interaction diff --git a/systems/docgpt/src/core/prompts.py b/systems/openrag/src/core/prompts.py similarity index 95% rename from systems/docgpt/src/core/prompts.py rename to systems/openrag/src/core/prompts.py index c7f56ca..aa27838 100644 --- a/systems/docgpt/src/core/prompts.py +++ b/systems/openrag/src/core/prompts.py @@ -23,7 +23,7 @@ CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_condense_template) -_qa_template = """You are DocGPT, a friendly assistant for the R data.table open source project. +_qa_template = """You are OpenRAG, a friendly assistant for the R data.table open source project. Scope rules (follow strictly): - Only answer questions about data.table (its codebase, docs/wiki, or contributing). diff --git a/systems/docgpt/src/domain/__init__.py b/systems/openrag/src/domain/__init__.py similarity index 100% rename from systems/docgpt/src/domain/__init__.py rename to systems/openrag/src/domain/__init__.py diff --git a/systems/docgpt/src/domain/assistant.py b/systems/openrag/src/domain/assistant.py similarity index 100% rename from systems/docgpt/src/domain/assistant.py rename to systems/openrag/src/domain/assistant.py diff --git a/systems/docgpt/src/domain/auth.py b/systems/openrag/src/domain/auth.py similarity index 100% rename from systems/docgpt/src/domain/auth.py rename to systems/openrag/src/domain/auth.py diff --git a/systems/docgpt/src/domain/content.py b/systems/openrag/src/domain/content.py similarity index 100% rename from systems/docgpt/src/domain/content.py rename to systems/openrag/src/domain/content.py diff --git a/systems/docgpt/src/domain/responses/__init__.py b/systems/openrag/src/domain/responses/__init__.py similarity index 100% rename from systems/docgpt/src/domain/responses/__init__.py rename to systems/openrag/src/domain/responses/__init__.py diff --git a/systems/docgpt/src/domain/responses/assistant.py b/systems/openrag/src/domain/responses/assistant.py similarity index 100% rename from systems/docgpt/src/domain/responses/assistant.py rename to systems/openrag/src/domain/responses/assistant.py diff --git a/systems/docgpt/src/domain/storage.py b/systems/openrag/src/domain/storage.py similarity index 100% rename from systems/docgpt/src/domain/storage.py rename to systems/openrag/src/domain/storage.py diff --git a/systems/docgpt/src/logging/discord_logger.py b/systems/openrag/src/logging/discord_logger.py similarity index 100% rename from systems/docgpt/src/logging/discord_logger.py rename to systems/openrag/src/logging/discord_logger.py diff --git a/systems/docgpt/src/port/__init__.py b/systems/openrag/src/port/__init__.py similarity index 100% rename from systems/docgpt/src/port/__init__.py rename to systems/openrag/src/port/__init__.py diff --git a/systems/docgpt/src/port/assistant.py b/systems/openrag/src/port/assistant.py similarity index 100% rename from systems/docgpt/src/port/assistant.py rename to systems/openrag/src/port/assistant.py diff --git a/systems/docgpt/src/port/content.py b/systems/openrag/src/port/content.py similarity index 100% rename from systems/docgpt/src/port/content.py rename to systems/openrag/src/port/content.py diff --git a/systems/docgpt/tests/__init__.py b/systems/openrag/tests/__init__.py similarity index 100% rename from systems/docgpt/tests/__init__.py rename to systems/openrag/tests/__init__.py diff --git a/systems/docgpt/tests/conftest.py b/systems/openrag/tests/conftest.py similarity index 100% rename from systems/docgpt/tests/conftest.py rename to systems/openrag/tests/conftest.py diff --git a/systems/docgpt/tests/fixtures/__init__.py b/systems/openrag/tests/fixtures/__init__.py similarity index 100% rename from systems/docgpt/tests/fixtures/__init__.py rename to systems/openrag/tests/fixtures/__init__.py diff --git a/systems/docgpt/tests/test_assistant_metadata.py b/systems/openrag/tests/test_assistant_metadata.py similarity index 100% rename from systems/docgpt/tests/test_assistant_metadata.py rename to systems/openrag/tests/test_assistant_metadata.py diff --git a/systems/docgpt/tests/test_discord_logging.py b/systems/openrag/tests/test_discord_logging.py similarity index 89% rename from systems/docgpt/tests/test_discord_logging.py rename to systems/openrag/tests/test_discord_logging.py index 7db68c7..35d43e3 100644 --- a/systems/docgpt/tests/test_discord_logging.py +++ b/systems/openrag/tests/test_discord_logging.py @@ -20,9 +20,9 @@ def test_discord_logger_schema_and_insert(pg_dsn: str) -> None: logger = DiscordInteractionLogger(dsn=pg_dsn, rag_name="test-rag") row_id = logger.log_interaction( - question="What is DocGPT?", - rag_answer="DocGPT is a documentation assistant.", - rag_context='[{"source": "doc.md", "snippet": "DocGPT..."}]', + question="What is OpenRAG?", + rag_answer="OpenRAG is a documentation assistant.", + rag_context='[{"source": "doc.md", "snippet": "OpenRAG..."}]', llm_answer="Generic answer", discord_user_id="user123", discord_channel_id="channel123", diff --git a/systems/docgpt/uv.lock b/systems/openrag/uv.lock similarity index 100% rename from systems/docgpt/uv.lock rename to systems/openrag/uv.lock