wickkiey/tamil-wikipedia-chunked huggingface dataset:
# Module:Road data/strings/doc

## Syntax

### Switching

Some logic is too complicated to represent with only format strings. This framework provides several methods to express complex data. All of these involve storing a nested table as the value of a field.  
The most straightforward functionality provided by nested tables is switching. In its most basic form, the table consists of a series of key-value pairs, with the keys being route numbers and the values being the format strings used by those routes. Usually, the format string returned does not need parsing, but the option is there. A <code>default</code> entry should be provided to handle any route numbers not explicitly stated. The following is a representative example of route-based switching (from Module:Road data/strings/USA/AR):
<syntaxhighlight lang="lua">
AR.AR = {
shield = {
default = "Arkansas %route%.svg",
["917"] = "Arkansas 917-1.svg",
["980"] = "Arkansas 980(Airport).svg"
},
link = "Arkansas Highway %route% [dab||(%dab%)|]",
abbr = "Hwy.&nbsp;%route%",
}
</syntaxhighlight>  
In this example, Highways 917 and 980 have non-standard shield names, which are explicitly provided. Other route numbers use the default format.  
Switching on other arguments is also allowed. The name of the argument to be used for switching is stated in the <code>arg</code> field of the table. Nesting switches on different arguments is also allowed. A good example that uses both forms of switching can be found in Ontario:
<syntaxhighlight lang="lua">
local regionalShields = {
arg = "county",
["Essex"] = "Essex County Road %route%.png",
["York"] = "York Regional Road %route%.svg",
["Durham"] = "Durham Regional Road %route%.svg",
["Niagara"] = "Niagara Regional Road %route%.svg",
["Simcoe"] = {
["52"] = "Simcoe county road 52.png",
default = "Simcoe County Road %route%.JPG"
}
}
</syntaxhighlight>  
In this example, which is a shield table that is reused by several types in Ontario, the <code>county</code> argument is used for the primary switch. If the route is in Simcoe County, a second switch is performed, this time on the route number.
# Module:Road data/strings/doc

## Syntax

### Existence testing

Another use for tables is existence testing. If a table has the <code>ifexists</code> field set to <code>true</code>, the parser will perform existence testing on the result of parsing the <code>default</code> field. If the test fails, the result of parsing the <code>otherwise</code> field is returned. Existence testing may be chained by using a second ifexists table as the value of the first table's <code>otherwise</code> field, and so on. Here's an example of nested existence testing (from Module:Road data/strings/GBR):
<syntaxhighlight lang="lua">
GBR.B = {
shield = {
ifexists = true,
default = "UK road B%route%.svg",
otherwise = {
ifexists = true,
default = "UK road B%route%.png"
}
},
link = "",
abbr = "B%route%"
}
</syntaxhighlight>
# Module:Road data/strings/doc

## Syntax

### Hooks

Due to technical limitations, these string modules cannot contain functions. Rather than force functionality into the string framework, the parser can call functions in a separate hooks module. The functions in this module, Module:Road data/parser/hooks, are more-or-less fully functional functions. The exact functionalities of these hooks are beyond the scope of this documentation. Descriptions of these hooks may be found on their documentation page.  
Generally speaking, a hook is called by setting the <code>hook</code> field in a table as equal to the name of a hook. Hooks receive two arguments, both tables: <code>parameters</code>, which is the table in the definition; and <code>args</code>, which is simply the table of arguments normally passed to the parser. The hook returns a string, which is then parsed as usual. A powerful feature of hooks is that they can add arbitrary values to the argument table, which may be referenced in the string returned by the hook. Generally, the format string returned by the hook is specified in some form by the <code>default</code> field of the table, though there are exceptions. Here is an example of a hook (from Module:Road data/strings/MEX):
<syntaxhighlight lang="lua">
MEX.SH = {
shield = {
ifexists = true,
arg = "state",
SON = "HIGHWAYSON %route%.jpg",
NLE = "Nuevo Leon State Highway %route%.PNG",
default = ""
},
link = {
hook = "mask",
mask = "Road data/masks/MEX",
base = "state",
masked = "fullstate",
default = "%fullstate% State Highway %route%"
},
abbr = "SH&nbsp;%route%"
}
</syntaxhighlight>  
In this example, the parser will process the link by calling the <code>mask</code> hook. In short, this hook takes the argument referenced in <code>base</code>, passes it through the mask module specified in <code>mask</code>, and stores it in the field in the arguments noted in <code>masked</code>. The hook returns the string given in <code>default</code>, which has access to the <code>fullstate</code> argument added by the hook.
# Module:Road data/strings/doc

## Syntax

### Other functionality

Functionality exists to display multiple shields for one route, which is used to display tolled and free shields for routes where they differ. This is done by supplying a table with two values, which are listed without indices. The parser is called twice by the calling module, and it returns one shield per call. An example may be found in Texas:
<syntaxhighlight lang="lua">
TX.Both = {
shield = {"Texas %route%.svg", "Toll Texas %route% new.svg"},
link = "Texas State Highway %route%",
abbr = "SH&nbsp;%route%",
width = 40
}
</syntaxhighlight>
# Module:Road data/strings/doc

## Structure

Each country has its own module. In the United States and Canada, each state/territory/province also has its own module. Each module begins with a comment stating the name of the country or state, followed by the root table declaration, as follows (from Module:Road data/strings/USA/AS):
<syntaxhighlight lang="lua">
-- American Samoa
local AS = {}
</syntaxhighlight>  
The root table is named based on the established abbreviation for the country or state, which is the same as the abbreviation used in the module title. This table stores the various types used in that particular place. Most of the remaining code in the module defines these various types. The module ends by returning the root table:
<syntaxhighlight lang="lua">
return AS
</syntaxhighlight>
# Module:Road data/strings/doc

## Structure

### Aliasing

There are two ways to define a type as an alias. If the type is defined within the module, simply set the new type as equal to the type being aliased, as shown above (from Module:Road data/strings/HKG):
<syntaxhighlight lang="lua">
HKG.Route = {
shield = "HK Route%route%.svg",
link = "Route %route% (Hong Kong)",
abbr = "Route&nbsp;%route%"
}  
HKG.route = HKG.Route
</syntaxhighlight>  
If the type is defined in a separate module, such as a state highway type being used in another state's module, a special syntax may be used to refer to that module (from Module:Road data/strings/USA/NJ):
<syntaxhighlight lang="lua">
NJ.NY = {alias = {module = "USA/NY", type = "NY"}}
</syntaxhighlight>  
This code sets the <code>NY</code> type as a link to the <code>NY</code> type in Module:Road data/strings/USA/NY. The parser will import that module and process the type as if the original module had declared it itself. The alias declaration may not add or override any data in the type table it points to.
# Module:Road data/strings/doc

## Structure

### Inheriting types

It is possible to predefine several types for a location by inheriting them from another module. In this example, the module for Albania inherits all of the specified types from the Europe module.  
<syntaxhighlight lang="lua">
-- Albania
local ALB = {}  
local util = require("Module:Road data/util")
util.addAll(ALB, require("Module:Road data/strings/EUR"))
</syntaxhighlight>  
Only one module may be inherited at this time.
# Module:Road data/strings/doc

## Advanced uses

It is possible to create multiple types based on a specified pattern using <code>ipairs</code>. In this example from Module:Road data/strings/USA/WA, the <code>US 1926</code>, <code>US 1948</code>, and <code>US 1961</code> types are all created from the same code. At the bottom that is an override for <code>US 1961</code>'s <code>shieldmain</code>.
<syntaxhighlight lang="lua">
for _,year in ipairs({"1926", "1948", "1961"}) do
WA["US " .. year] = {
shield = format("US %%route%% (%s).svg", year),
shieldmain = format("US %%route%% Washington %s.svg", year),
base = WA.US.base,
name = WA.US.name,
link = WA.US.link,
abbr = WA.US.abbr,,
}
end  
WA["US 1961"].shieldmain = "US %route% (1961).svg"
</syntaxhighlight>  
Similarly, subtypes can be created in the same manner. This example creates 9 subtypes each for <code>WA</code> and <code>SR</code>. The <code>aux</code> is inherited from Module:Road data/strings/USA. That, in turn, modifies <code>auxType</code> and <code>spec</code> accordingly.  
<syntaxhighlight lang="lua">
for _,type in ipairs({'WA', 'SR'}) do
for _,auxType in ipairs({"Alt", "Bus", "Byp", "Conn", "Opt", "Scenic", "Spur", "Temp", "Truck"}) do
local spec = WA[" aux "][auxType]
WA[type .. "-" .. auxType] = {
shield = WA[type].shield,
shieldmain = WA[type].shieldmain,
name = WA[type].name .. " " .. spec.name,
link = WA[type].link .. " " .. spec.name .. suffix,
abbr = WA[type].abbr .. " " .. spec.abbrsuffix,
banner = spec.bannerprefix .. " plate.svg",
aux = spec.aux,
width = WA[type].width
}
end
end
</syntaxhighlight>
# Module:Road data/strings/doc

## Style

There are a few style guidelines that should be followed:
1. Align table fields using tabs. All tables should be aligned so that fields line up with each other, as shown in the above examples.
1. Each table field should be on its own line.
1. Add spaces to either side of an assignment operator (equals sign).
1. Leave a blank line between types. Type aliases should be set off from their base type by a blank line, but no blank lines should be placed between the aliases themselves.
# வார்ப்புரு:Module exports/doc

is used to list the exports of a Lua module.
# வார்ப்புரு:Module exports/doc

## Usage

<code></code>
# வார்ப்புரு:Module exports/doc

## Usage

### Parameters

- - The first unnamed parameter is the module to show exports for. Defaults to the current page.
- - A Lua pattern that when matched excludes the export from the final output.
# வார்ப்புரு:Module exports/doc

## Examples

-
-  
<includeonly></includeonly>
# Module:Road data/strings/ASIA

-- Asia
local ASIA = {}  
ASIA.AH = {
shield = "Tabliczka AH%route%.svg",
name = "Asian Highway %route%",
link = {
default = "AH%route% [dab||(%dab%)|]",
['6'] = "AH6 (highway)",
['64'] = "AH6 (highway)"
},
abbr = "AH%route%",
color = "ASIA",
nbrowse = "Asian Highway Network"
}  
return ASIA
# வார்ப்புரு:N.b./doc

## Usage

A simple template to be used in various to-do lists for easier organization of solved and unsolved issues.  
Per MOS:ICONS, it should not be used in mainspace.  
=
# Module:Exports

local p = {}  
local TableTools = require('Module:TableTools')
local getArgs = require('Module:Arguments').getArgs  
function p.exports
local args = getArgs
local title = args[1] or mw.title.getCurrentTitle.fullText
local moduleExports = require(title)  
local keys = TableTools.keysToList(moduleExports, function (a, b)
return string.lower(a) < string.lower(b)
end)  
local outputKeys = {}
for _, v in ipairs(keys) do
if not args.exclude or not v:match(args.exclude) then
table.insert(outputKeys, '<code><span>' .. v .. '</span></code>')
end
end  
return mw.text.listToText(outputKeys)
end  
return p
# வார்ப்புரு:Demo inline/doc

## Usage

Used to include examples of template use in documentation pages.  
Like , this template takes an unnamed argument in tags, and displays it unprocessed (as code), then as processed wikitext.  
Unlike , this template presents the processed output on the *same line* as the unprocessed input, separated by an arrow. This is useful for compactly demonstrating a series of different behaviors of the same template.
# வார்ப்புரு:Demo inline/doc

## Example

The code  
<code></code>  
produces the template example:
# Module:Demo/doc

## Usage

### Usage via templates

This module supports  
1. invoke:|*main*}}  
and  
1. invoke:|*inline*}}  
The input must be wrapped in tags or else it may be processed before the module can read it.
# Module:Demo/doc

## Usage

### Usage in a module

If you want to use this in another module (such as to make the output prettier), you can get values like so:
<syntaxhighlight lang="lua">require('Module:demo').get</syntaxhighlight>  
Function returns a table containing:
- <code>source</code> = the source code (without wrappers, characters substituted with html entities)
- <code>output</code> = the execution result of the source.
- <code></code> = the from which this template took the parameter.  
By default, takes the first parameter of . If the uses a different parameter name for the nowiki-wrapped source, then place that name (as a string) as the second parameter, like so  
Example:
<syntaxhighlight lang="lua">
local p = {}  
function p.main
local parts = require('Module:demo').get
return '…Pretty HTML… <pre>' .. parts.source .. '</pre> …More pretty HTML… ' .. parts.output .. ' …Even more pretty HTML…'
end  
return p</syntaxhighlight>
# Module:Road data/strings/UNK

--[==[
To inspect the content of this data module, use Special:ExpandTemplates
and enter the following input text:  
To inspect the content of this data module when editing, enter the following
into the Debug console:
local util = require("Module:Road data/util")
print(util.arrayToString(p))
To inspect a particular route type, change `p` above to include the route type,
e.g., `p.I` and `p["US-Hist"]`.
]==]  
-- UNKNOWN COUNTRY -- THIS IS JUST A FAILSAFE
local UNK = {}  
local util = require("Module:Road data/util")  
UNK[''] = {
shield = "",
name = "%route%",
link = "",
abbr = "%route%"
}
# Module:Road data/browsetable

local p = {}  
function p._browsetable(content, styles)
if not content then return nil end  
local tbl = mw.html.create('table'):addClass('browse-table')
tbl:wikitext(content)
tbl:cssText(styles)  
return mw.getCurrentFrame:extensionTag{
name = 'templatestyles', args = { src = 'Module:Road data/browsetable/styles.css' }
} .. tostring(tbl)
end  
function p.browsetable
local getArgs = require('Module:Arguments').getArgs
local args = getArgs
return p._browsetable(args[1], args.style)
end  
return p
# Module:Road data/browsetable/styles.css

/* */
.browse-table {
width: 100%;
background: ;
-collapse: collapse;
display: table;
margin: 0;
}  
.browse-table + .browse-table,
.browse-table + link + .browse-table,
.browse-table + style + .browse-table {
margin-top: ;
}  
.browse-table td {
padding: 0;
: ;
vertical-align: middle;
}  
.browse-table tr:not(:first-child) td {
padding-top: ;
}
# Module:Road data/browsetable/doc

This module exports the functions <code>browsetable</code> (for use from wikitext) and <code>_browsetable</code> (for use within Lua). The functions can serve as a container for the output of Module:Road data/browse while also adding padding between multiple instances of Module:Road data/browse.
# Module:Road data/browsetable/doc

## Example

<includeonly></includeonly>
# வார்ப்புரு:Demo/doc

This template simply places template code (or any other code) in a tag and then places the rendering of that code below.
<syntaxhighlight lang="wikitext">  
</syntaxhighlight>  
**** You must wrap tags around the source to be demonstrated (or use , which has a demo-escape example), like so:
<syntaxhighlight lang="wikitext" inline></syntaxhighlight>  
Failure to wrap tags around the source may cause the source to be executed before it reaches this template.
<syntaxhighlight lang="wikitext" inline></syntaxhighlight> produces:
# வார்ப்புரு:Demo/doc

### Pre style

Set to add any CSS text to the tag.  
For example, <syntaxhighlight lang="wikitext" inline></syntaxhighlight> will produce:
# வார்ப்புரு:Demo/doc

### Separator

You can change the separator between the and the template by setting the parameter.
<syntaxhighlight lang="wikitext"></syntaxhighlight>  
You may use can make the demonstration fit in a table:  
Instead of using , you can also specify the number of line breaks between the code and the template in the parameter.
# வார்ப்புரு:Demo/doc

### Reverse order

Use to show the code snippet and the result in reverse order:
<syntaxhighlight lang="wikitext"></syntaxhighlight>  
will produce
# வார்ப்புரு:Demo/doc

### Category removal

For templates that add categories (e.g. ), set (or ) to anything to prevent them from showing up in the output:
# வார்ப்புரு:Demo/doc

### Module

If the template used is based on Lua, you can pass args directly to the demonstrated module by invoking Module:Demo like so: (this would reduce server stress)  
Note: It will attempt to preserve line breaks for unnamed params, but such is impossible for named params since those are stripped of whitespace/order before being passed to the module. Also note, you should use instead of (all args you don't want being passed should be prefixed with <code>demo_</code> if not already)
# வார்ப்புரு:Demo/doc

## TemplateData

<templatedata>
{
"params": {
"1": {
"label": "Content",
"description": "must be wrapped in <nowiki>"
},
"sep": {
"description": "Number of line breaks, or wikitext to fill in as the linebreak"
},
"nocat": {
"type": "boolean",
"aliases": [
"demo_kill_categories"
]
},
"result_arg": {},
"style ": {
"label": "<syntaxhighlight> style"
},
"reverse": {
"label": "Reverse order",
"description": "Show the code snippet and the result in reverse order",
"type": "boolean",
"default": "0",
"autovalue": "1"
}
}
}
</templatedata>
# Module:Road data/strings/USA
}
USA.Postal = USA.Post  
USA.CR = {
shield = "CR %route% jct.svg",
shieldmain = "[county||%county% |]County %route%.svg",
base = "County Road %route%",
name = "County Road %route%",
link = "",
abbr = "CR %route%"
}  
USA.road = {
shield = '',
name = "%route%",
link = '',
abbr = "%route%",
}  
USA.USBR = {
shield = "USBR %route%.svg",
name = "U.S. Bicycle Route %route%",
link = "U.S. Bicycle Route %route%" .. USA[" dab "],
abbr = "USBR %route%",
orientation = "upright"
}  
USA["USBR 2009"] = {
shield = "USBR %route% (2009).svg",
name = USA.USBR.name,
link = USA.USBR.link,
abbr = USA.USBR.abbr,
orientation = USA.USBR.orientation
}  
util.addAll(USA, require("Module:Road data/strings/USA/regional/GRR"))
util.addAll(USA, require("Module:Road data/strings/USA/regional/NER"))
util.addAll(USA, require("Module:Road data/strings/USA/regional/Tour"))
util.addAll(USA, require("Module:Road data/strings/USA/regional/Trails"))  
return USA
# Module:Road data/strings/USA/regional/GRR

--[==[
To inspect the content of this data module, use Special:ExpandTemplates
and enter the following input text:  
To inspect the content of this data module when editing, enter the following
into the Debug console:
local util = require("Module:Road data/util")
print(util.arrayToString(p))
To inspect a particular route type, change `p` above to include the route type,
e.g., `p.I` and `p["US-Hist"]`.
]==]  
-- Great River Road
local GRR = {}  
local util = require("Module:Road data/util")  
GRR.GRR = {
shield = "GreatRiverRoad.svg",
name = "Great River Road",
link = "Great River Road",
abbr = "Great River Road[route|| (%route% Route)|]",
banner = {
arg = "route",
National = "National Route plate.svg",
["Alternate National"] = "Alternate plate.svg",
Alternate = "Alternate plate.svg"
},
bannersuffix = "Vermont",
nbrowse = "Scenic Byways",
nbrowselinks = {
[1] = "National",
[2] = "National Forest",
[3] = "BLM",
[4] = "NPS",
}
}  
GRR["GRR-Spur"] = {
shield = "GreatRiverRoad brown.svg",
link = "Great River Road",
abbr = "Great River Road Spur",
banner = "Spur plate brown.svg",
bannersuffix = "brown",
nbrowse = GRR.GRR.nbrowse,
nbrowselinks = GRR.GRR.nbrowselinks
}  
return GRR
# Module:Road data/strings/USA/regional/NER

-- New England
local NER = {}  
NER.NER = {
shield = "New England %route%.svg",
name = "New England Route %route%",
link = "Route %route% (New England)",
abbr = "Route %route%",
color = "hist",
nbrowse = "New England road marking system"
}  
return NER
# Module:Road data/strings/USA/regional/Tour

--[==[
To inspect the content of this data module, use Special:ExpandTemplates
and enter the following input text:  
To inspect the content of this data module when editing, enter the following
into the Debug console:
local util = require("Module:Road data/util")
print(util.arrayToString(p))
To inspect a particular route type, change `p` above to include the route type,
e.g., `p.I` and `p["US-Hist"]`.
]==]  
-- Great Lakes Circle Tours
local Tour = {}  
local util = require("Module:Road data/util")  
Tour.Tour = {
shield = {
default = "Great Lakes Circle Tour.svg",
LSCT = "Lake Superior Circle Tour.svg",
LMCT = "Lake Michigan Circle Tour.svg",
LHCT = "Lake Huron Circle Tour.svg",
LECT = "Lake Erie Circle Tour.svg",
["LSCT-Spur"] = "Lake Superior Circle Tour brown.svg",
["LMCT-Spur"] = "Lake Michigan Circle Tour brown.svg",
["LHCT-Spur"] = "Lake Huron Circle Tour brown.svg"  
},
name = {
default = "Great Lakes Circle Tour",
LSCT = "Lake Superior Circle Tour",
LMCT = "Lake Michigan Circle Tour",
LHCT = "Lake Huron Circle Tour",
LECT = "Lake Erie Circle Tour",
["LSCT-Spur"] = "Lake Superior Circle Tour",
["LMCT-Spur"] = "Lake Michigan Circle Tour",
["LHCT-Spur"] = "Lake Huron Circle Tour"  
},
link = {
default = "Great Lakes Circle Tour",
LSCT = "Lake Superior Circle Tour",
LMCT = "Lake Michigan Circle Tour",
LHCT = "Lake Huron Circle Tour",
LECT = "Lake Erie Circle Tour",
["LSCT-Spur"] = "Lake Superior Circle Tour",
["LMCT-Spur"] = "Lake Michigan Circle Tour",
["LHCT-Spur"] = "Lake Huron Circle Tour"  
},
abbr = {
default = "GLCT",
LSCT = "LSCT",
LMCT = "LMCT",
LHCT = "LHCT",
LECT = "LECT",
["LSCT-Spur"] = "LSCT Spur",
["LMCT-Spur"] = "LMCT Spur",
["LHCT-Spur"] = "LHCT Spur"  
},
bannersuffix = {
default = "green",
["LSCT-Spur"] = "brown",
["LHCT-Spur"] = "brown"  
},
nbrowse = "Great Lakes Circle Tour"
}  
return Tour
# Module:Road data/strings/USA/MI
}  
MI.CTR = {
shield = "City Truck Route.svg",
link = "",
abbr = "City Truck Route"
}  
MI.WI = {alias = {module = "USA/WI", type = "WI"}}
MI["US-WI"] = {alias = {module = "USA/WI", type = "US"}}
MI.IN = {alias = {module = "USA/IN", type = "IN"}}
MI["US-IN"] = {alias = {module = "USA/IN", type = "US"}}
MI.OH = {alias = {module = "USA/OH", type = "OH"}}
MI["US-OH"] = {alias = {module = "USA/OH", type = "US"}}
MI.ON = {alias = {module = "CAN/ON", type = "ON"}}  
return MI
# Module:Transclusion count/data/I
["Module:If_any_equal"] = 241000,
["Module:If_empty"] = 4010000,
["Module:If_in_category"] = 169000,
["Module:If_in_page"] = 16000,
["Module:If_not_given_or_empty"] = 58000,
["Module:If_preview"] = 316000,
["Module:If_preview/configuration"] = 316000,
["Module:If_preview/styles.css"] = 316000,
["Module:In_lang"] = 373000,
["Module:Indent"] = 4900,
["Module:Infobox"] = 4370000,
["Module:Infobox/dates"] = 74000,
["Module:Infobox/styles.css"] = 4640000,
["Module:Infobox/utilities"] = 2300,
["Module:Infobox3cols"] = 311000,
["Module:InfoboxImage"] = 5020000,
["Module:Infobox_body_of_water_tracking"] = 19000,
["Module:Infobox_cyclist_tracking"] = 16000,
["Module:Infobox_dim"] = 218000,
["Module:Infobox_dim/data"] = 90000,
["Module:Infobox_gene"] = 13000,
["Module:Infobox_mapframe"] = 1000000,
["Module:Infobox_military_conflict"] = 26000,
["Module:Infobox_military_conflict/styles.css"] = 26000,
["Module:Infobox_multi-lingual_name"] = 22000,
["Module:Infobox_multi-lingual_name/data"] = 22000,
["Module:Infobox_power_station"] = 3200,
["Module:Infobox_road"] = 26000,
["Module:Infobox_road/browselinks"] = 25000,
["Module:Infobox_road/errors"] = 25000,
["Module:Infobox_road/length"] = 26000,
["Module:Infobox_road/locations"] = 25000,
["Module:Infobox_road/map"] = 25000,
["Module:Infobox_road/route"] = 26000,
["Module:Infobox_road/sections"] = 25000,
["Module:Infobox_television"] = 61000,
["Module:Infobox_television_disambiguation_check"] = 68000,
["Module:Infobox_television_episode"] = 13000,
["Module:Infobox_television_season_disambiguation_check"] = 9700,
["Module:Infobox_television_season_name"] = 10000,
["Module:Internet_Archive"] = 19000,
["Module:Is_article"] = 2200,
["Module:Is_infobox_in_lead"] = 450000,
["Module:Is_instance"] = 348000,
["Module:Iso2nationality"] = 227000,
["Module:Italic_title"] = 1170000,
["Module:Italic_title2"] = 5700,
}
# கிழக்கு நுசா தெங்காரா

**கிழக்கு நுசா தெங்காரா**; (ஆங்கிலம்: *East Nusa Tenggara*; இந்தோனேசியம்: *Nusa Tenggara Timur*) என்பது இந்தோனேசியா, சுண்டா தீவுகளில் உள்ள ஒரு மாநிலம்; இதன் தலைநகரம் குப்பாங். இந்த மாநிலம், தெற்கில் இந்தியப் பெருங்கடலையும்; வடக்கில் புளோரஸ் கடலையும் எதிர்கொள்ளும் சுந்தா தீவுகளின் கிழக்குப் பகுதியை உள்ளடக்கியது. இதன் மொத்த நிலப்பரப்பு 46,446.64 கிமீ<sup>2</sup>.  
இந்த மாநிலம் 500-க்கும் மேற்பட்ட தீவுகளைக் கொண்டுள்ளது. அவற்றுள் மிகப்பெரியவை சும்பா தீவுகள், புளோரெஸ் மற்றும் மேற்கு தீமோரின் ஒரு பகுதி. இந்த மாநிலம் 21 ஆட்சிப் பகுதிகளாகப் பிரிக்கப்பட்டுள்ளது; மற்றும் ஆட்சிப் பகுதி அளவிலான குப்பாங் நகரம், இந்த மாநிலத்தின் தலைநகரமாகவும் உள்ளது.  
கிழக்கு நுசா தெங்காராவில் உள்ள லியாங் புவா குகையில் Liang Bua, சுமார் 190,000 ஆண்டுகளுக்கு முன்பு இருந்தே மனிதர்கள் வசித்து வந்ததாக தொல்பொருள் ஆய்வுகள் காட்டுகின்றன. குகையின் உள்ளே உள்ள தொல்பொருள் மண் அடுக்குகளில் இருந்து புளோரெஸ் மனிதர்கள் உள்ளிட்ட தொடக்கக்கால மனிதர்களின் உறைவிடமாக இருந்து இருக்கலாம் என்பது தெரிய வருகிறது.
# கிழக்கு நுசா தெங்காரா

## பொது

கிழக்கு நுசா தெங்காரா மாநிலம், கொமோடோ தேசிய பூங்கா, லாபுவான் பாஜோ, கெலிமுட்டு ஏரி மற்றும் கவர்ச்சிகரமான கடற்கரைகள் போன்ற இயற்கை அழகு ஈர்ப்புகளுக்காக அறியப்படுகிறது. பல்வேறு பழங்குடிகள்; பல்வேறு மொழிகள்; இகாட் நெசவு; சும்பா பசோலா விழா போன்ற பண்பாட்டுக் கூறுகளுக்கு இந்த மாநிலம் பெயர் பெற்றது.  
கிழக்கு நுசா தெங்காரா ஒரு வலுவான சமயப் பரப்புரை வரலாற்றையும் கொண்டுள்ளது. இங்கு பெரும்பான்மையானவர் கத்தோலிக்க சமயத்தைப் பின்பற்றுகின்றனர். இந்த மாநிலத்திற்கு அருகில் இருக்கும் தெற்கு பப்புவா மாநிலத்திலும் ரோமன் கத்தோலிக்கம் பிரதான மதமாக உள்ளது. அத்துடன், இந்த மாநிலத்தின் கடல் சுற்றுச்சூழல் அமைப்பும் மிகவும் வளமாக உள்ளது; கடலில் மூழ்கிக் குளிப்பவர்களுக்கு *(divers)* பிரபலமான இடமாகவும் அமைகிறது.
# கிழக்கு நுசா தெங்காரா

## வரலாறு

1945-ஆம் ஆண்டு இந்தோனேசிய விடுதலை நாள் அறிவிப்பிற்குப் பிறகு, இந்தோனேசியாவின் கிழக்குப் பகுதியில் உள்ள நிலப்பகுதி; கிழக்கு இந்தோனேசியா மாநிலமாக அறிவிக்கப்பட்டது. 1949-ஆம் ஆண்டு, இந்தோனேசியாவிற்கு இறையாண்மையை மாற்றுவதில் இடச்சுக்காரர்களுடன் செய்துகொள்ளப்பட்ட ஒப்பந்தத்தின் ஒரு பகுதியாக இந்தோனேசியா அமெரிக்காவில் இந்தோனேசியா மேலும் சேர்க்கப்பட்டது.  
1945-ஆம் ஆண்டு இந்தோனேசிய விடுதலை நாள் அறிவிப்பிற்குப் பிறகு, இந்தோனேசியாவின் கிழக்குப் பகுதி கிழக்கு இந்தோனேசிய மாநிலமாக அறிவிக்கப்பட்டது. 1949-ஆம் ஆண்டு இந்தோனேசிய தேசிய புரட்சிக்குப் பின்னர், இந்தோனேசிய ஐக்கிய மாநிலங்கள் உருவாக்கப்பட்டது. அப்போது இடச்சுக்காரர்களுடன் செய்து கொள்ளப்பட்ட உடன்படிக்கையின் ஒரு பகுதியாக, ஐக்கிய இந்தோனேசியாவில், கிழக்கு நுசா தெங்காரா மாநிலம் சேர்க்கப்பட்டது.  
1958-ஆம் ஆண்டில், இந்தோனேசியாவின் (UU) எண். 64/1958 சட்டம் இயற்றப்பட்டது. அதன்படி, சிறு சுண்டாத் தீவுகளில் மூன்று மாநிலங்கள் நிறுவப்பட்டன. அவை: பாலி, மேற்கு நுசா தெங்காரா மற்றும் கிழக்கு நுசா தெங்காரா.
# கிழக்கு நுசா தெங்காரா

## புவியியல்

சிறு சுண்டா தீவுகளின் கிழக்கே அமைந்துள்ள கிழக்கு நுசா தெங்காரா மாநிலம்; தெற்கில் இந்தியப் பெருங்கடலையும்; வடக்கில் புளோரஸ் கடலையும் எதிர்கொள்கிறது. இந்த மாநிலம் திமோர் தீவின் மேற்குப் பகுதியில் கிழக்கு திமோர் (*Timor-Leste*) மாநிலத்தின் எல்லையைக் கொண்டுள்ளது. மேலும் மேற்கு நுசா தெங்காரா (*Nusa Tenggara Barat*) மாநிலத்திற்கும் மலுக்கு மாநிலத்திற்கும் அருகில் உள்ளது.  
இந்த மாநிலம் சுமார் 566 தீவுகளைக் கொண்டுள்ளது. அவற்றில் மிகப்பெரிய மற்றும் மிகவும் ஆதிக்கம் செலுத்தும் தீவுகள் புளோரெஸ், சும்பா தீவுகள் மற்றும் திமோரின் மேற்குப் பகுதி தீவுகள் ஆகும். சிறிய தீவுகளில் அடோனாரா, அலோர், கொமோடோ, லெம்பாட்டா, மெனிபோ, இரைஜுவா, இரிஞ்சா, ரோட் தீவு, சவு, செமாவ் தீவு மற்றும் சோலோர் ஆகியவை அடங்கும். மாநிலத்தின் மிக உயரமான இடம் கடல் மட்டத்திலிருந்து 2,427 மீட்டர் உயரத்தில் உள்ள முத்திசு மலை; இந்த மலை தென் மத்திய திமோர் பிராந்தியத்தில் உள்ளது.
# கிழக்கு நுசா தெங்காரா

## காலநிலை

கிழக்கு நுசா தெங்காரா காலநிலை வெப்பமண்டல காலநிலையாக வகைப்படுத்தப்பட்டுள்ளது. கிழக்கு நுசா தெங்காராவில் ஆண்டு முழுவதும் அதிக அளவு மழைப்பொழிவு உள்ளது. இங்குள்ள காலநிலை கோப்பன்-கீகர் அமைப்பின்படி Af என வகைப்படுத்தப்பட்டுள்ளது. ஆண்டு சராசரி வெப்பநிலை 24 °C ஆகும்; சராசரி ஆண்டு மழைப்பொழிவு 4420 மிமீ ஆகும்.
# Module:Road data/strings/DEU

--[==[
To inspect the content of this data module, use Special:ExpandTemplates
and enter the following input text:  
To inspect the content of this data module when editing, enter the following
into the Debug console:
local util = require("Module:Road data/util")
print(util.arrayToString(p))
To inspect a particular route type, change `p` above to include the route type,
e.g., `p.I` and `p["US-Hist"]`.
]==]  
-- Germany
local DEU = {}  
local util = require("Module:Road data/util")
util.addAll(DEU, require("Module:Road data/strings/EUR"))  
DEU.E.shield = "European_Road_%route%_number_DE.svg"
DEU.Elink = "European route E%route% in Germany"  
DEU.A.shield = "Bundesautobahn %route% number.svg"
DEU.A.abbr = "A %route%" --Autobahn
DEU.A.name = "Federal Motorway %route%"
DEU.A.link = "Bundesautobahn %route%"
DEU.A.color = "autobahn"
DEU.A.translation = "Bundesautobahn %route%"
DEU.A.lang = "de"  
DEU.B.shield = "Bundesstraße %route% number.svg"
DEU.B.abbr = "B %route%" --Bundestraße
DEU.B.name = "Federal Highway %route%"
DEU.B.link = "Bundesstraße %route%" --Bundestraße
DEU.B.color = "DEU-B"
DEU.B.translation = "Bundesstraße %route%"
DEU.B.lang = "de"  
DEU.L.abbr = "L%route%" --Landesstraße
DEU.L.name = "State Highway %route%"
DEU.L.translation = "Landesstraße %route%"
DEU.L.lang = "de"  
DEU.K.abbr = "K%route%" --Kreisstraße
DEU.K.name = "County Highway %route%"
DEU.K.translation = "Kreisstraße %route%"
DEU.K.lang = "de"  
DEU.Scenic = {
shield = '',
name = "%route%",
link = '',
abbr = "%route%",
browse = '',
color = "DEU-scenic"
}
return DEU
# Module:Road data/strings/EUR

-- Europe
local EUR = {}  
local util = require("Module:Road data/util")
local format = mw.ustring.format  
-- European roads
EUR.E = {
shield = "Tabliczka E%route%.svg",
name = "E%route%",
link = "European route E%route% [dab||(%dab%)|]",
abbr = "E%route%",
color = "EUR",
}  
-- Most common road types in Europe
for _,type in ipairs({"A", "B", "D", "G", "H", "K", "L", "M", "N", "O", "P", "R", "S", "T", "V"}) do
EUR[type] = {
shield = "",
name = type .." %route%",
link = "",
abbr = type .." %route%",
}
end  
local transEuropean = {
["1"] = 'Baltic–Adriatic Corridor',
["2"] = 'North Sea–Baltic Corridor',
["3"] = 'Mediterranean Corridor',
["4"] = 'Oreient/East–Med Corridor',
["5"] = 'Scandinavian–Mediterranean Corridor',
["6"] = 'Rhine–Alpine Corridor',
["7"] = 'Atlantic Corridor',
["8"] = 'North Sea–Mediterranean Corridor',
["9"] = 'Rhine–Danube Corridor',  
}  
EUR["TEN-T"] = {
shield = '',
shieldmain = '',
name = transEuropean,
link = transEuropean,
abbr = transEuropean,
color = "EUR",
}  
EUR.road = {
shield = '',
shieldmain = '',
name = "%route%",
link = '',
abbr = "%route%",
browse = '',
}  
return EUR
# Module:Road data/strings/USA/NY
# Module:Road data/strings/USA/TX
name = TX.SH.name .. " Express ",
link = TX.SH.base .. " Express ".. suffix2,
abbr = TX.SH.abbr .. " Express",
banner = "",
maint = {
default = NTTA,
["1"] = CTTP
}
}  
TX["Loop Dual"] = {
shield = {"Texas Loop %route%.svg", "Toll Texas %route% new.svg"},
shieldmain = {"Texas Loop %route%.svg", "Toll Texas %route% new.svg"},
name = TX.Loop.name,
link = TX.Loop.link,
abbr = TX.Loop.abbr
}  
TX["Loop-Express"] = {
shield = {
default = TX.Loop.shield, --actually has a special variant of the toll shield http://maps.google.com/maps?ll=32.820965,-97.201688&spn=0.012929,0.024784&t=m&z=16&layer=c&cbll=32.820896,-97.205511&panoid=coL0_PX6xfY9Ia3Rkrr8cA&cbp=12,353.63,,1,-8.72
["1"] = "1 Express Lane free.svg"
},
name = "Loop %route% Express",
link = TX.Loop.base .. " Express ".. suffix2,
abbr = TX.Loop.abbr .. " Express",
banner = "",
bannersuffix = "blue",
maint = {
default = "",
["1"] = CTRMA
}
}  
TX["SL-Express"] = TX["Loop-Express"]  
TX.CR.shield = {
arg = "county",
default = "",
Brazoria = "Generic green square county %route%.svg"
}
TX.CR.maint = ""
TX.CR.browse = ""
TX.CR.browselinks = ""  
TX.MEX = {alias = {module = "MEX", type = "FH"}}
TX["I-AR"] = {alias = {module = "USA/AR", type = "I"}}
TX["US-AR"] = {alias = {module = "USA/AR", type = "US"}}
TX.AR = {alias = {module = "USA/AR", type = "AR"}}
TX.LA = {alias = {module = "USA/LA", type = "LA"}}
TX.OK = {alias = {module = "USA/OK", type = "SH"}}
TX.NM = {alias = {module = "USA/NM", type = "NM"}}  
return TX
# வார்ப்புரு:Routelist row/doc

This template creates a row in a standard U.S. highway list. Use it in conjunction with and to create a table of highway routes.
# வார்ப்புரு:Routelist row/doc

## Usage

<syntaxhighlight lang="wikitext" width=100%>  
</syntaxhighlight>  
- **state:** the postal abbreviation for the state this route lies in
- **type:** the type prefix for the highway (e.g. US, SH, CR). All types that are accepted by for the selected state are accepted by this template.
- **route:** the route number of the highway.
- **dab:** disambiguation, if needed.
- **length_mi:** the length of the highway in miles. Must contain a number value (passing a string will result in an error). Converts the given length to kilometers and fills in the "Length (km)" column.
- **length_km:** the length of the highway in kilometers. Must contain a number value (no strings). Converts the given length to miles and fills in the "Length (mi)" column.
- **length_ref:** reference for the length value.
- **terminus_a:** west or south terminus.
- **terminus_b:** north or east terminus.
- **beltway:** if present, overrides <code>terminus_a</code> and <code>terminus_b</code>, displaying its argument in a single cell that spans both columns.
- **local:** any local names the highway has. Usually restricted to lists of county-level scope (i.e. lists of highways by county, county routes, etc.). Any list which includes this column must call this template with <code></code> for each instance of the template in order to generate the column, or the <code>local</code> parameter will be ignored.
- **established:** date that the highway designation was established. Must be a date value (passing a value that does not validate as a date will result in an error). Only the year will be displayed in the "Formed" column, though exact dates will be used for sortkey purposes. Inserting "proposed" here colors the row yellow and displays "—" in the "Removed" column. If omitted, "—" will be displayed in the "Formed" column.
- **decommissioned:** takes either "yes" or the date that the highway designation was removed from service. Only the year will be displayed in the "Removed" column, though exact dates will be used for sortkey purposes. Past dates color the row gray. If omitted, "current" will be displayed in the Removed column (unless <code>established=proposed</code>). Inserting "yes" here colors the row gray and displays "—" in the "Removed" column.
- **established_ref, decommissioned_ref:** reference for the established and decommissioned values.
- **circa_established**, **circa_decommissioned:** if "yes", the corresponding column will be marked as an approximate (*circa*) date.
- **notes:** content to be displayed in the "Notes" column. If omitted, no cell will be produced. If passed the value "", a blank cell will be produced.
- **noshield:** set to anything to disable the shield
# வார்ப்புரு:Routelist row/doc

## Template data

<templatedata>
{
"params": {
"state": {
"label": "State",
"description": "The postal abbreviation of the state the route is located in",
"example": "OK",
"type": "string",
"required": true
},
"type": {
"label": "Highway type",
"description": "The type of the highway, as defined in the Module:Road data/strings family of modules.",
"example": "SH",
"type": "string",
"required": true
},
"route": {
"label": "Route number",
"description": "The number of the route",
"example": "21",
"type": "string",
"suggested": true
},
"dab": {
"label": "Disambiguation",
"description": "Any necessary disambiguation (city, etc.)",
"example": "Tulsa",
"type": "string"
},
"length_mi": {
"label": "Length (miles)",
"description": "The length of the route in miles.",
"example": "22.3",
"type": "number"
},
"length_km": {
"label": "Length (kilometers)",
"description": "The length of the route in kilometers.",
"example": "42.1",
"type": "number"
},
"length_ref": {
"label": "Length reference",
"description": "Reference for the length value.",
"suggested": true
},
"terminus_a": {
"label": "Starting terminus",
"description": "The western or southern terminus of the route.",
"type": "string",
"suggested": true
},
"terminus_b": {
"label": "Finishing terminus",
"description": "The eastern or northern terminus of the route.",
"type": "string",
"suggested": true
},
"beltway": {
"label": "Beltway",
"description": "Substitute for terminus arguments.",
"type": "string"
}
},
"description": "This template creates a row in a standard U.S. highway list.",
"format": "block"
}
</templatedata>
# வார்ப்புரு:Routelist row/doc

## Template data

### Usage notes

<includeonly></includeonly>
# Module:Routelist row
end
elseif widthCode == 'US1926' then
banner = format("", bannerFile)
elseif args.state == 'CA' then
local route = args.route
local type = args.type
if type == 'US-Bus' then
if #route >= 3 then
banner = format("", bannerFile)
else
banner = format("", bannerFile)
end
elseif type == 'CA-Bus' or type == 'SR-Bus' then
if #route >= 3 then
banner = format("", bannerFile)
else
banner = format("", bannerFile)
end
end
end
banner = banner .. '
'
else
banner = ''
end  
local shield
if not noshield then
local shieldFile, second = parser(args, 'shieldlist') or parser(args, 'shield') or ''
if shieldFile == nil or shieldFile == '' then
shield = ''
elseif type(shieldFile) == 'table' then
shieldFile, second = shieldFile[1], shieldFile[2]
end
if second and type(second) == 'string' then
local shield1 = format("", shieldFile)
local shield2 = format("", second)
shield = shield1 .. shield2
elseif shield == '' then
shield = ''
else
shield = shieldFile and format("", shieldFile) or ''
end
else
shield = ''
end  
local linkTarget = (not args.nolink) and parser(args, 'link')
local abbr = parser(args, 'abbr')
local link
if linkTarget then
link = format("%s", linkTarget, abbr)
else
link = abbr
end
if not link then error("Type not in database: " .. args.type) end
local sortkey = sortkey(args)
local sortedLink = format("<span data-sort-value=\"%s&#32;!\">%s</span>", sortkey, link)
local route = banner .. shield .. ' ' .. sortedLink
return '|' .. route
end  
function p.row
local args = getArgs -- Gather passed arguments into easy-to-use table  
local established = args.established
local decommissioned = args.decommissioned
local routeState = getRouteState(established, decommissioned)
local anchor = args.anchor or sortkey(args)
local rowdef = routeState.row .. string.format(' id="%s"', anchor)
local route = route(args)
local length = length(args)
local termini = termini(args)
local localname = localname(args)
local dates = dates(established, decommissioned, routeState, args)
local notesArg = args.notes
local notes = notes(notesArg)  
local row = {rowdef, route, length, termini, localname, dates, notes}
return table.concat(row, '\n')
end  
function p.gap
local args = getArgs -- Gather passed arguments into easy-to-use table  
local routeState = getRouteState(established, decommissioned)
local anchor = args.anchor or sortkey(args)
local rowdef = routeState.row .. string.format(' id="%s"', anchor)
local route = route(args)
local gap = gap(args)  
local row = {rowdef, route, gap}
return table.concat(row, '\n')
end  
return p
# மரபணு கணிப்பீடு

மரபணு கணிப்பீடு (ஆ) டிஎன்ஏ கம்ப்யூட்டிங் என்பது வழக்கத்திற்கு மாறான கணினி மயமாக்கலில் வளர்ந்து வரும் உயிர் தகவலியல் கிளையாகும், இது வழக்கமான மின்னணு கணக்கீட்டிற்கு மாறாக மரபணு, உயிர்வேதியியல் மற்றும் மூலக்கூறு உயிரியல் மாதிரிகளைப் பயன்படுத்துகிறது. இத்துறை மரபணு கணக்கீட்டின் கோட்பாடு, சோதனைகள், பயன்பாடுகள், ஆய்வுகள் மற்றும் மேம்பாடு குறித்த ஆய்வியலைக் கொண்டுள்ளது. 1994 ஆம் ஆண்டில் *லென் அடில்மேன்* ஒரு மரபணு மாதிரி கணிப்பீடு பயன்பாட்டை நிரூபித்ததன் மூலம் இந்தத் துறை முதலில் தொடங்கப்பட்டாலும், இப்போது சேமிப்பு தொழில்நுட்பங்களின் வளர்ச்சி, நானோ அளவிலான வரைவலை முறைமைகள், செயற்கை கட்டுப்படுத்திகள், எதிர்வினை தொடரிகள் போன்ற பல வழிகாட்டுதல்களுடன் இது விரிவுபடுத்தப்பட்டுள்ளது.
# மரபணு கணிப்பீடு

## பயன்பாடுகள், எடுத்துக்காட்டுகள் மற்றும் சமீபத்திய முன்னெடுப்புகள்

1994 ஆம் ஆண்டில் லியோனார்டு அடில்மேன் மரபணுக் கணினியின் முதல் முன்மாதிரியை வழங்கினார். டிடி-100 என்பது மரபணுக் கரைசலின் 100 மைக்ரோலிட்டர்கள் நிரப்பப்பட்ட சோதனைக் குழாய் வடிவமைப்பு ஆகும். அவர் இயக்கிய ஹாமில்டோனியன் பாதை மரபணு குறித்த சில சந்தேகங்களை ஒரு சில உதாரணங்களுடன் ஒப்பிட்டு தீர்க்க முடிந்தது. அடில்மேனின் பரிசோதனையில், ஹாமில்டோனியன் பாதைச் சிக்கல் சமகால "விற்பனையாளரின் பயணச் சிக்கல்" என்ற முறைமையை குறியீடாகக் கொண்டு செயல்படுத்தப்பட்டது. இந்த நோக்கத்திற்காக, வெவ்வேறு மரபணுத் துண்டுகள் உருவாக்கப்பட்டன, அவை ஒவ்வொன்றும் ஒப்பிட்டு தொகுதிகளாக மாற வேண்டிய மற்ற தனித்தனி நகரத்தொகுதிகளைக் குறித்தன. இத் துண்டுகள் ஒவ்வொன்றும் உருவாக்கப்பட்ட ஏனைய துண்டுகளுடன் இணைக்கும் திறனைக் கொண்டவை. இந்த மரபணுத் துண்டுகள் தயாரிக்கப்பட்டு சோதனைக் குழாயில் கலக்கப்பட்டன. சில நொடிகளில், சிறிய துண்டுகள் ஒன்றன் பின் ஒன்றாக பெரும் தொகுதியாக உருவாகி, வெவ்வேறு பயணப் பாதைகளைக் குறித்தன.ஒரு இரசாயன எதிர்வினை மூலம், சம்பந்தம் இல்லாத நீண்ட பாதைகளைக் குறிக்கும் மரபணுத் துண்டுகள் அகற்றப்பட்டன.  
எஞ்சியவை ஆய்வின் பலதரப்பட்ட சந்தேகங்களின் தீர்வாகவும் அமைந்தன. ஆனாலும் ஒட்டுமொத்தமாக, சோதனை ஒரு வாரம் வரை நீடித்தது. இருப்பினும், தற்போதைய தொழில்நுட்ப வரம்புகள் முடிவுகளை மதிப்பீடு செய்வதைத் தடுக்கின்றன. எனவே, இந்த சோதனை பயன்பாட்டிற்கு ஏற்றதாக அமையவில்லை, இருப்பினும் இது ஒருதரப்பட்ட கருத்தின் சான்றாகும்.
# மரபணு கணிப்பீடு

## பயன்பாடுகள், எடுத்துக்காட்டுகள் மற்றும் சமீபத்திய முன்னெடுப்புகள்

### ஒருங்கிணைந்த சிக்கல்கள்

இந்தப் பிரச்சினைகளுக்கான முதல் முடிவுகள் லியோனார்ட் அடில்மேனால் பெறப்பட்டன.  
- 1994: ஏழு உச்சிமாநாடுகளுடன் ஒரு வரைபடத்தில் ஹாமில்டோனியன் பாதையை தீர்ப்பது.
- 2002: NP-முழுமையான சிக்கலையும், 20 மாறிகளுடன் 3-SAT சிக்கலையும் தீர்ப்பது.
# மரபணு கணிப்பீடு

## பயன்பாடுகள், எடுத்துக்காட்டுகள் மற்றும் சமீபத்திய முன்னெடுப்புகள்

### டிக்-டாக்-கால் விளையாட்டு

2002 ஆம் ஆண்டில், ஜே. மெக்டொனால்ட், டி. ஸ்டீபனோவிக் மற்றும் எம். ஸ்டோஜனோவிக் ஆகியோர் ஒரு மனித வீரருக்கு இணையாக டிக்-டாக்-டோ விளையாடக்கூடிய டிஎன்ஏ கணினியை உருவாக்கினர். கணிப்பான் விளையாட்டின் ஒன்பது சதுரங்களுடன் தொடர்புடைய ஒன்பது தொட்டிகளுடன் இருந்தன. ஒவ்வொரு தொட்டியிலும் ஒரு அடி மூலக்கூறு மற்றும் மரபணு நொதிகளின் பல்வேறு சேர்க்கைகளும் உள்ளன. அடி மூலக்கூறு ஒரு மரபணு இழையால் ஆனது, அதன் ஒரு முனையில் ஓர் ஒளிரும் இரசாயனக் குழுவும், மறுமுனையில் ஓர் அடக்குமுறை குழுவும் ஒட்டப்பட்டன. ஆதி மூலக்கூறுகள் பாதியாக வெட்டப்பட்டால் மட்டுமே ஒளிரிகள் செயலில் இருக்கும். மரபணு நொதிகள் தர்க்கரீதியான செயல்பாடுகளை உருவகப்படுத்துகின்றன. எடுத்துக்காட்டாக, தருக்கமுறை செயல்பாட்டை பெருக்கம் செய்ய இரண்டு குறிப்பிட்ட வகையான மரபிழைகள் அறிமுகப்படுத்தப்பட்டால் மட்டுமே அத்தகைய மரபணுக்கள் வெளிப்படும்.  
முன்னிருப்பாக, கணினி முதலில் மையச் சதுக்கத்தில் விளையாடியதாகக் கருதப்படுகிறது. மனித வீரர் விளையாடக்கூடிய மீதமுள்ள எட்டு பெட்டிகளுடன் தொடர்புடைய எட்டு வெவ்வேறு வகையான மரபணு இழைகளுடன் தொடங்குகிறார். பெட்டி எண் ஒன்றை விளையாட, மனித வீரர் உள்ளீடு #i உடன் தொடர்புடைய அனைத்து தொட்டிகளிலும் இழைகளை ஊற்றுகிறார். இந்த இழைகள் தொட்டிகளில் இருக்கும் சில மரபணு நொதிகளுடன் பிணைக்கப்படுகின்றன, இதன் விளைவாக, இந்த தொட்டிகளில் ஒன்றில், மரபணு நொதியின் சிதைவு அடி மூலக்கூறுடன் பிணைக்கப்பட்டு அதை வெட்டுகிறது. மரபணுக் கணினி எந்தப் பெட்டியை இயக்குகிறது என்பதைக் குறிக்கும் வகையில், அதனுடன் தொடர்புடைய தொட்டி ஒளிரும் தன்மையைக் கொண்டது. உண்மையான டிக்-டாக்-டோவைப் போலவே, மனித வீரர் அடையக்கூடிய சிறந்ததை ஒரு சமநிலை என்பதை உறுதி செய்யும் வகையில் டி. என். ஏ நொதிகள் தொட்டிகளுக்கு இடையே பிரிக்கப்படுகின்றன.
# மரபணு கணிப்பீடு

## பயன்பாடுகள், எடுத்துக்காட்டுகள் மற்றும் சமீபத்திய முன்னெடுப்புகள்

### நரம்பியல் தொடர் அடிப்படையிலான கணிப்பான்

கால்டெக்கில் கெவின் செர்ரி மற்றும் லுலு கியான் ஆகியோர் 100-பிட் கையால் எழுதப்பட்ட இலக்கங்களை அடையாளம் காணக்கூடிய டிஎன்ஏ அடிப்படையிலான செயற்கை நரம்பியல் வலையமைப்பை உருவாக்கினர். வெவ்வேறு செறிவுகள் எடை மூலக்கூறுகளால் குறிக்கப்படும் பொருத்தமான எடைகளின் தொகுப்புடன் ஒரு கணினியில் முன்கூட்டியே நிரலாக்குவதன் மூலம் அவர்கள் இதைச் சாதித்தனர், அவை பின்னர் உள்ளீட்டு டி. என். ஏ இழைகளை வைத்திருக்கும் சோதனைக் குழாயில் சேர்க்கப்படுகின்றன.
# மரபணு கணிப்பீடு

## பயன்பாடுகள், எடுத்துக்காட்டுகள் மற்றும் சமீபத்திய முன்னெடுப்புகள்

### உள்மயமாக்கப்பட்ட (தற்காலிக சேமிப்பு போன்ற) கணினியுடன் மேம்படுத்தப்பட்ட வேகம்

மரபணு கணக்கீட்டின் சவால்களில் ஒன்று அதன் மெதுவான வேகம். டிஎன்ஏ உயிரியல் ரீதியாக இணக்கமான அடி மூலக்கூறு என்றாலும், சிலிக்கான் தொழில்நுட்பம் பயன்படுத்த முடியாத இடங்களில் இதைப் பயன்படுத்தலாம், அதன் கணக்கீட்டு வேகம் இன்னும் மிகவும் மெதுவாகவே உள்ளது. எடுத்துக்காட்டாக, புலத்தில் ஒரு அளவுகோலாகப் பயன்படுத்தப்படும் சதுர-வேர் சுற்று முடிக்க 100 மணி நேரங்களுக்கு மேல் ஆகும். வெளிப்புற நொதி மூலங்களுடன் புதிய வழிகள் வேகமான மற்றும் மிகவும் சிறிய சுற்றுகளை தெரிவிக்கும் அதே வேளையில், அதே வேளையில், சாட்டர்ஜி மற்றும் பலரால் முன்மொழியப்பட்ட கருத்தாக்கம் உள் டிஎன்ஏ சுற்றுகள் மூலம் கணக்கீட்டை விரைவுபடுத்துவதற்கான துறையில் ஒரு குறிப்பிடத்தக்க கருத்தாக்கத்தை நிரூபித்தனர், இந்த கருத்து மற்ற குழுக்களால் மேலும் ஆராயப்படுகிறது. இந்த யோசனை, முதலில் கணினி கட்டிடக்கலைத் துறையில் முன்மொழியப்பட்டாலும், இந்தத் துறையிலும் ஏற்றுக்கொள்ளப்பட்டுள்ளது. கணினி கட்டமைப்பில், அறிவுறுத்தல்கள் தொடர்ச்சியாக செயல்படுத்தப்பட்டால், அவற்றை தற்காலிக சேமிப்பில் ஏற்றுவது தவிர்க்க முடியாமல் விரைவான செயல்திறனுக்கு வழிவகுக்கும், இது உள்மயமாக்கல் கொள்கை என்றும் அழைக்கப்படுகிறது. ஏனென்றால், வேகமான தற்காலிக நினைவகத்தில் உள்ள வழிமுறைகளுடன், அவற்றை பிரதான நினைவகத்திற்கு உள்ளேயும் வெளியேயும் மாற்ற வேண்டிய அவசியமில்லை, இது மெதுவாக இருக்கலாம்.இரண்டு வடிவமைப்புகளும் சில சிக்கல்களை எதிர்கொண்டாலும் (எதிர்வினை கசிவுகள் போன்ற) இது டி. என். ஏ கணினி துறையில் குறிப்பிடத்தக்க முன்னேற்றத்தைக் குறிக்கிறது. வேறு சில குழுக்களும் வாயில் மறுபயன்பாட்டு சிக்கலை தீர்க்க முயற்சித்துள்ளன.  
டிஎன்ஏ கணினி மற்றும் மீளக்கூடிய கணினி நுட்பங்களை இணைப்பதன் மூலம் மரபணு கணினிகளில் மீளக்கூடிய வாயில்கள் மற்றும் சுற்றுகளை செயல்படுத்துவதற்கான "டிஎன் ஏ கணினிகளில் திரும்பக்கூடிய சுற்றுகளின் தொகுப்பு உத்தி" என்ற கட்டுரையில் இழை இடப்பெயர்ச்சி எதிர்வினைகளைப் பயன்படுத்துதல் (எஸ்ஆர்டி) மீளக்கூடிய முன்மொழிவுகள் வழங்கப்படுகின்றன. இந்த ஆய்வுக் கட்டுரை, முந்தைய முறைகளை விட கட்டமைக்கப்பட்ட சுற்றுகளின் சராசரி நீளம் மற்றும் செலவைக் கொண்ட டிஎன்ஏ கணினிகளில் என்-பிட் மீளக்கூடிய சுற்றுகளை ஒருங்கிணைப்பதற்கான ஓர் உலகளாவிய மீளக்கூடிய வாயில் நூலகத்தையும் (யுஆர்ஜிஎல்) முன்மொழிகிறது.
# மரபணு கணிப்பீடு

## வழிமுறைகள்

மரபணுவை அடிப்படையாகக் கொண்ட ஒரு கணினி சாதனத்தை உருவாக்க பல வழிமுறைகள் உள்ளன, ஒவ்வொன்றும் அதன் சொந்த நன்மைகள் மற்றும் தீமைகளுடன் உள்ளடக்கியதாகவுள்ளன. இவற்றில் பெரும்பாலானவை டிஎன்ஏ அடிப்படையில் இலக்கமுறை தர்க்கத்துடன் தொடர்புடைய அடிப்படை தர்க்க வாயில்களை (AND, OR, NOT) உருவாக்குகின்றன. டிஎன்ஏ நொதிகள், டியோக்சியோலிகோனியூக்ளியோடைடுகள், நொதிகள், வால்தொகு மாற்றம் ஆகியவை சில வெவ்வேறு தளங்களுள் அடங்கும்.
# மரபணு கணிப்பீடு

## வழிமுறைகள்

### மரபிழை இடமாற்ற வழிமுறைகள்

மரபணு கணினி மற்றும் மூலக்கூறு நிரலாக்கத்தில் மிகவும் அடிப்படை செயல்பாடு இழை நகர்வு பொறிமுறையாகும். தற்போது, இழையின் இடப்பெயர்ச்சியை செய்ய இரண்டு வழிகள் உள்ளன.  
- கால்தொகுதி நடுத்தர இழையின் இடப்பெயர்ச்சி (TMSD)
- பாலிமரேஸ் அடிப்படையிலான இழைகளின் இடப்பெயர்ச்சி (PSD)
# மரபணு கணிப்பீடு

## வழிமுறைகள்

### கால் பரிமாற்றம்

எளிய இழைகள் நகரும் திட்டங்களைத் தவிர, மரபணு கணினிகளும் கால் பிடிப்பு பரிமாற்றத்தின் கருத்தைப் பயன்படுத்தி உருங்கிணைந்து கட்டப்பட்டுள்ளன. இந்த அமைப்பில், ஒரு உள்ளீட்டு மரபணு இழையும் மற்றொரு மரபணு மூலக்கூறில் உள்ள ஒட்டும் முனை அல்லது கால்தொகுதியுடன் பிணைக்கப்படுகிறது, இது மூலக்கூறிலிருந்து மற்றொரு இழைப் பிரிவை இடமாற்றம் செய்ய அனுமதிக்கிறது. இது AND, OR, மற்றும் NOT வாயில்கள் மற்றும் சமிக்ஞை பெருக்கிகள் போன்ற மட்டு தர்க்க கூறுகளை உருவாக்க அனுமதிக்கிறது, அவை தன்னிச்சையாக பெரிய கணினிகளுடன் இணைக்கப்படலாம். இந்த வகை டிஎன்ஏ கணினிகளுக்கு நொதிகள் அல்லது மரபணுவின் எந்த வேதித் திறனும் தேவையில்லை.