OpenLLM-France/wikimedia huggingface dataset:
# Java JDBC using SQLite/Connecting

Assuming that your classpath is now established, and your JDK is ready to go, we can have a quick and dirty attempt to throw together a very simple database with only one table in it. As this is something of a disposable 'HelloWorld' mini-app on steroids, let's call it 'HelloDatabase'.
You really need to know one thing about the JDBC driver: its registered DriverName. For SqlLite this is:
    org.sqlite.JDBC
This value is used to register the driver in Java. Different JDBC drivers for different database implementations have different registered DriverNames. While it is entirely possible to discover DriverNames from the containing jar file(s) programatically, this lies outside the scope of this document and they can be looked up fairly quickly on the Internet e.g. at .
Now we come to constructing the URL string which is used in establishing the connection to the database. Different JDBCs for different database types have different URL definitions; the SqlLite URL string really just needs to know that it is a jdbc of the type 'sqlite' and the name of the target database which we wish to use. If for example we wish to connect to a new database called order.db we would need to compose a string comprised of the string 'jdbc', the database type name, in this case 'sqlite' plus the name of the database, separated by colons, i.e.:
    jdbc:sqlite:order.db
other examples
    jdbc:sqlite://dirA/dirB/dbfile
    jdbc:sqlite:/DRIVE:/dirA/dirB/dbfile
    jdbc:sqlite:///COMPUTERNAME/shareA/dirB/dbfile
an in-memory option is also available.
As a minimal set of imports for this mini-app (and for most simple JDBC connectors), you will want the following set of imports available as shown in the following code. The two .*MetaData imports are useful and often necessary for debugging and investigative purposes, as well as being handy for abstraction and ultimate reduction in the quantity of hard code that your programs will require.
You should now also find that you have a file called hello.db in your working directory, (or whatever else you called it in the database name component for the URL). If you attempt to run this code more than once, you will get a SQL Exception error since you will be trying to create a table that already exists; you can delete the .db file, or use SqLite to drop the table, or insert a new String with a drop table statement in it and use stmt.executeUpdate to run the drop string before attempting to create the table...
* Next Page: Improving
* Previous Page: Preparation
# Java JDBC using SQLite/Improving

The code on the previous page, whilst usable, is lumpy and more procedural than object-oriented. Typically in a real world situation the database specific code would be located in a class of its own, and then created and used as necessary as a discrete object.
Let's have a look at how we might think about doing this.
It's an improvement on the previous cut since we have now the possibility to have more than one database connection in play by use of the instantiation of the proposed new class DbClass. Moreover since the constructor takes a database URL as an argument it would be feasible to make this proposed class service more than one SqLite database, (and, in fact, service a completely different database type using a different JDBC provider if one is available). If you consider this carefully, what this should be suggesting to you is that in fact what we will ultimately need is an abstract base class of generalised database methods, from which we can then inherit to provide a concrete class which is database type specific, e.g. we have an abstract base class called something like DbBaseClass from which we can derive such classes as SqLiteDbClass, OracleDbClass, MySQlDbClass.
You will note that only java.sql.ResultSet is now needed for import into main as the database logic will be encapsulated elsewhere. Ultimately again we should be thinking about encapsulating that untidy ResultSet for loop block as a method in yet another class which is specific to handling outcomes of queries, with a view to providing its methods to an Interface class which bridges the concrete implementation of the database logic and the way that the data is returned etc. However, this is somewhat of a digression at the moment since what we really are interested in for now are the practicalities of getting our database to do what we want it to do.
The main method anticipates there being (at least) three publicly available methods, as well as having (at least) one constructor which takes the URL as an argument:
* void execute(String)
* ResultSet executeQuery(String)
* void close
It will inevitably also need a number of private methods and fields to satisfy this encapsulation. Let's start with the constructor and the obvious methods which it will need to provide a viable database class.
Obviously this is a very pared down implementation of a putative database class, and it really isn't all that object oriented. However it does represent a considerable step forward from the initial HelloDatabase.java which we began with.
* Next page: Example base class
* Previous page: Connecting
# Java JDBC using SQLite/Metadata
### Working with metadata

The point always comes with working with database objects when you need to understand more about the nature of the database structure than perhaps you do at the time of writing the code. Database tables get changed, a column type may be changed from a date to string type for instance, or a new column may be added or deleted; potentially you may have to reference a table which has not even yet been built or which is constructed on the fly. It is at this juncture that a rather handy facet of JDBC can be brought to bear: the metadata interfaces ResultSetMetaData and DatabaseMetaData.
It is important to remember when working with resultsets is that arrays are constructed from a SQL perspective, i.e. they start with an index with a value of 1 and not 0. You should also note that there are potentially issues with SqLite and JDBC when working with metadata on a table with 0 rows; rsmd.getColumnType for example, won't work, whereas rsmd.getColumnName curiously will.
Let's consider the following rudimentary method from which we can know the extent of the columns which any arbitrary ResultSet is returning:
So, using the previous Db.executeQry(java.lang.String) wrapper method we can now do something very simple like:
Now we need to know the column types.....
This will return an array of integers expressing the column types which are in our ResultSet. We may need to handle these integer values as strings, so the alternative way of doing this is as follows:
The correlation between the integer array and the string array is an aspect of the java.sql.Types class. Either way will work for programmatic purposes.
So we now know the ResultSet's column extent and its data types. Now we need to know the column names so we can reference them. Here again ResultSetMetaData provides the answer:
So, using the previous Db.executeQry wrapper method we can now begin to handle our unknown and/or unforeseeable database structure:
# Java JDBC using SQLite/Preparation

Assuming that you have a Java environment correctly configured, and that you can run up a simple HelloWorld program, etc, the first thing is to locate your JDBC jar file and add it to your classpath.

### Classpathing Windows

In Windows environments this is typically done by entering your Control Panel, available from the Start menu, clicking the System icon, and then selecting the Advanced System settings option, selecting the Advanced tab, followed by hitting the Environment Variables button. This is marginally different in the various Windows OS environments but at the end of the day you need to be able to set your environment variables. If you share the computer, probably the best thing to do is to create a CLASSPATH variable in your local user settings, unless, of course you want other users to also be able to access the jar file.
If one already exists you can just append the fully qualified path and file name to the existing entries in the CLASSPATH variable, using a semi-colon as a separator e.g. where you had a CLASSPATH string which looked like:
    c:\workDir;c:\jars\jfugue.jar
and you had renamed and put the SqlLite jar file in the same directory as the existing entry, as c:\jars\SqliteJdbc.jar, your amended CLASSPATH string will now look like:
    c:\workDir;c:\jars\jfugue.jar;c:\jars\SqliteJdbc.jar
You can check the status of your CLASSPATH environment variable by typing SET CLASSPATH at the command prompt.
NB if you are already working in a DOS command box, changes will not become apparent in that session, you will need to start a new command box for the changes to be realised.

### Classpathing Unix shells

The syntax for your classpathing will depend on the shell you are using, and can be fully discovered by using the "man {shellname}" command.
bash & ksh syntax:
    export CLASSPATH=$CLASSPATH:/java/classes:/home/jars/SqliteJdbc.jar
csh syntax:
    set CLASSPATH = ($CLASSPATH /java/classes /home/jars/SqliteJdbc.jar)
To view your CLASSPATH environment variables, "echo $CLASSPATH" will show you what you need to know.
* Next page: Connecting
* Previous page: Introduction
# Data Types

* {primitive types}
# Java JDBC using SQLite/Appendix
### SqLite Column Types

-7 BIT
-6 TINYINT
-5 BIGINT
-4 LONGVARBINARY
-3 VARBINARY
-2 BINARY
-1 LONGVARCHAR
0 NULL
1 CHAR
2 NUMERIC
3 DECIMAL
4 INTEGER
5 SMALLINT
6 FLOAT
7 REAL
8 DOUBLE
12 VARCHAR
91 DATE
92 TIME
93 TIMESTAMP
1111 OTHER
# Java JDBC using SQLite/Example base class

This page provides an example of a base class you can use as a skeleton for creating your own, and ideas of ways of extending this class. You should note that your central focus of concern should be on getting your initial context set up correctly, and there are many and diverse ways of skinning this particular cat. This base class is abstract since we will want to extend it to more precisely suit our requirements. There is however nothing particularly esoteric in there to prevent you concretizing this class by declaring it public and using it out of the box, modifying and supplying your own constructor(s) accordingly.
You should also note that there are a number of fields and methods in this base class which are declared public which more properly should be declared private, however these have been left public for visibility and since you may wish to experiment with the implications of some of the calls. Additionally, leaving these fields and methods public gives you a broad brush scope to invoke and adjust them by reflection.

### Base Class

* Next page: Extending the base class
* Previous page: Improving
# Java JDBC using SQLite/Introduction

This book deals with the problem of using Java to make connections to databases and successfully handle data in the databases. It assumes a basic understanding of Java concepts.
The example database used is freely available as a download from http://www.sqlite.org/; at time of writing the recommended version was Version 3.6.14.2. It is recommended that you download a copy of this if you intend to proceed with this tutorial since it will allow you to visit your databases independently of the Java programs to assess and evaluate the data structures and contents. In addition to this you will also need a functional Java JDK, optimally release 1.5 or higher since this gives support to the much improved JDBC 2.0 drivers; ideally you will have the very latest Java release. You will also need a downloaded copy of the JDBC jar file in order to connect your Java programs to the database. The JDBC jar files can be found at a number of locations (e.g. http://www.xerial.org/trac/Xerial/wiki/SQLiteJDBC). Most of what is said in here can equally well be applied to any other database connection; the reason SQLite is used is because of its exceedingly low and lightweight costs, and because there is a freely available front end for further investigation of data and data structures.
In summation then, you need:
* a reference copy of SQLite from http://www.sqlite.org/
* a JDK
* a SqLite jar file
A basic explanation of JDBC drivers and their usage is available on Wikipedia at .
Next Page: Preparation Previous Page: Title Page
# Java JDBC using SQLite
## Table of Contents

* Introduction
* Preparation
* Connecting
* Improving the Database Code
* Example base class
* Extending the base class
* Working with data
* Working with Binary Large Objects (BLOBs) in SQLite
* Metadata
* Afterword
* Appendix
* Things to clarify in with this book - to be removed when complete
Next page: Introduction
# Java JDBC using SQLite/Extending the base class
### Extending the Base Class

Let's now turn to extending and implementing our concrete class. First we'll create a concrete implementation of the base abstract class with no additional functionality:
We can now call our database connector in our codebase and invoke it with the driver name and the url using the parameterised constructor.....
Here we have these parameters hard-coded but typically you would have these values stored as values against keys in a properties file and load them from there.
Now let's move on and add some functionality to the MyDb child.
Interesting but not particularly useful. However the parameterised overload should be saying to you that if you can do this in a generic sort of way, there is nothing to stop you from making a per database type subclass; e.g. from Db you could subclass not only SqliteDb, but also OracleDb, MySqlDb etc, etc, and add to these the required database specific functionality.
The implications of this should be becoming apparent. By carefully structuring your class hierarchies and relationships, it is possible to provide as much or as little appropriate functionality as is necessary.
* Next page: Working with data
* Previous page: Example base class
# LMIs in Control/Click here to continue/Controller synthesis/Optimal State-Feedback Controllers with Structured Norm-Bounded Uncertainty

LMIs in Control/Click here to continue/Controller synthesis/Optimal State-Feedback Controllers with Structured Norm-Bounded Uncertainty
${\begin{aligned}{\text{If there exists some }}\Theta \in P\Theta ,P>0,{\text{ and }}Z{\text{ such that the LMI is feasible, then the system satisfies }}||y||_{L_{2}}\leq \gamma ||u||_{L_{2}}.{\text{ There also exists a controller with }}u(t)=Kx(t).\end{aligned}}$

## The System

    ${\begin{aligned}{\dot {x}}(t)&=Ax(t)+Bu(t)+Mp(t)+B_{2}w(t),&&p(t)=\Delta (t)q(t),\\q(t)&=Nx(t)+D_{12}u(t),&&\Delta \in {\bf {{\Delta }\;,||\Delta ||\leq 1}}\\y(t)&=Cx(t)+D_{22}u(t)\\\end{aligned}}$

## The Data

The matrices $A,B,M,B_{2},N,D_{12},C,D_{22}$.

## The Optimization Problem

${\text{Minimize }}\gamma$ subject to the LMI constraints.

## The LMI:

       ${\begin{aligned}{\text{Find}}\;&P>0,Z:\\{\begin{bmatrix}AP+BZ+PA^{T}+Z^{T}B^{T}+B_{2}B_{2}^{T}+M\Theta M^{T}&(CP+D_{22}Z)^{T}&PN^{T}+Z^{T}D_{12}^{T}\\CP+D_{22}Z&-\gamma ^{2}I&0\\NP+D_{12}Z&0&-\Theta \end{bmatrix}}<0\\\end{aligned}}$

## Conclusion:

The controller is $K=ZP^{-1}$.

## Implementation

https://github.com/mcavorsi/LMI

## Related LMIs

Quadratically Stabilizing Controllers with Parametric Norm-Bounded Uncertainty
H-infinity Optimal Quadratically Stabilizing Controllers with Parametric Norm-Bounded Uncertainty
Stabilizing State-Feedback Controllers with Structured Norm-Bounded Uncertainty

## External Links

* LMI Methods in Optimal and Robust Control - A course on LMIs in Control by Matthew Peet.
# LMIs in Control/Click here to continue/Controller synthesis/Quadratic Polytopic Full State Feedback Optimal Hinf Control
## Quadratic Polytopic Full State Feedback Optimal $H_{\infty }$ Control

For a system having polytopic uncertainties, Full State Feedback is a control technique that attempts to place the system's closed-loop system poles in specified locations based off of performance specifications given. $H_{\infty }$ methods formulate this task as an optimization problem and attempt to minimize the $H_{\infty }$ norm of the system.

## The System

Consider System with following state-space representation.
    ${\begin{aligned}{\dot {x}}(t)&=Ax(t)+B_{1}q(t)+B_{2}w(t)\\p(t)&=C_{1}x(t)+D_{11}q(t)+D_{12}w(t)\\z(t)&=C_{2}x(t)+D_{21}q(t)+D_{22}w(t)\\\end{aligned}}$
where $x\in \mathbb {R} ^{m}$ , $q\in \mathbb {R} ^{n}$ , $w\in \mathbb {R} ^{g}$, $A\in \mathbb {R} ^{mxm}$, $B_{1}\in \mathbb {R} ^{mxn}$, $B_{2}\in \mathbb {R} ^{mxg}$, $p\in \mathbb {R} ^{p}$ , $C_{1}\in \mathbb {R} ^{pxm}$, $D_{11}\in \mathbb {R} ^{pxn}$, $D_{12}\in \mathbb {R} ^{pxg}$, $z\in \mathbb {R} ^{s}$, $C_{2}\in \mathbb {R} ^{sxm}$, $D_{21}\in \mathbb {R} ^{sxn}$ , $D_{22}\in \mathbb {R} ^{sxg}$ for any $t\in \mathbb {R}$.
Add uncertainty to system matrices
    $A,B_{1},B_{2},C_{1},C_{2},D_{11},D_{12}$
New state-space representation
    ${\begin{aligned}{\dot {x}}(t)&=(A+A_{i})x(t)+(B_{1}+B_{i})q(t)+(B_{2}+B_{i})w(t)\\p(t)&=(C_{1}+C_{i})x(t)+(D_{11}+D_{i})q(t)+(D_{12}+D_{i})w(t)\\z(t)&=C_{2}x(t)+D_{21}q(t)+D_{22}w(t)\\\end{aligned}}$

## The Optimization Problem:

Recall the closed-loop in state feedback is:
$S(P,K)=$
       ${\begin{aligned}{\begin{bmatrix}A+B_{2}F&&B_{1}\\C_{1}+D_{12}F&&D_{11}\end{bmatrix}}\\\end{aligned}}$
This problem can be formulated as $H\infty$ optimal state-feedback, where K is a controller gain matrix.

## The LMI:

An LMI for Quadratic Polytopic $H\infty$ Optimal State-Feedback Control $||S(P(\Delta ),K(0,0,0,F))||_{H\infty }\leq \gamma$
$Y>0$
       ${\begin{aligned}{\begin{bmatrix}Y(A+A_{i})^{T}+(A+A_{i})Y+Z^{T}(B_{2}+B_{1,i})^{T}+(B_{2}+B_{1,i})Z&&*^{T}&&*^{T}\\(B_{1}+B_{1,i})^{T}&&-\gamma I&&*^{T}\\(C_{1}+C_{1,i})Y+(D_{12}+D_{12,i})Z&&(D_{11}+D_{11,i})&&-\gamma I\end{bmatrix}}<0\end{aligned}}$

## Conclusion:

The $H\infty$ Optimal State-Feedback Controller is recovered by $F=ZY^{-1}$
Controller will determine the bound $\gamma$ on the $H_{\infty }$ norm of the system.

## Implementation:

https://github.com/JalpeshBhadra/LMI/tree/master

## Related LMIs

Full State Feedback Optimal $H_{\infty }$ Controller

## External Links

* LMI Methods in Optimal and Robust Control - A course on LMIs in Control by Matthew Peet.
* LMI Properties and Applications in Systems, Stability, and Control Theory - A List of LMIs by Ryan Caverly and James Forbes.
* LMIs in Systems and Control Theory - A downloadable book on LMIs by Stephen Boyd.
# LMIs in Control/Click here to continue/Controller synthesis/Quadratic Polytopic Stabilization

A Quadratic Polytopic Stabilization Controller Synthesis can be done using this LMI, requiring the information about $A$,$\Delta _{A(t)}$ ,$B$ and $\Delta _{B(t)}$ matrices.

## The System

    ${\begin{aligned}{\dot {x}}(t)&=Ax(t)+Bu(t),\\x(0)&=x_{0},\end{aligned}}$
where $x(t)\in \mathbb {R} ^{n}$, $u(t)\in \mathbb {R} ^{m}$, at any $t\in \mathbb {R}$.
The system consist of uncertainties of the following form
    ${\begin{aligned}\Delta _{A(t)}=A_{1}\delta _{1}(t)+....+A_{k}\delta _{k}(t)\\\Delta _{B(t)}=B_{1}\delta _{1}(t)+....+B_{k}\delta _{k}(t)\\\end{aligned}}$
where $x\in \mathbb {R} ^{m}$,$u\in \mathbb {R} ^{n}$,$A\in \mathbb {R} ^{mxm}$ and $B\in \mathbb {R} ^{mxn}$

## The Data

The matrices necessary for this LMI are $A$,$\Delta _{A(t)}\,ie\,A_{i}$ ,$B$ and $\Delta _{B(t)}\,ie\,B_{i}$

## The Optimization and LMI:LMI for Controller Synthesis using the theorem of Polytopic Quadratic Stability

There exists a K such that
    ${\begin{aligned}{\dot {x}}(t)&=(A+\Delta _{A}+(B+\Delta _{B})K)x(t)\\\end{aligned}}$
is quadratically stable for $(\Delta _{A},\Delta _{B})\in C_{0}((A_{1},B_{2}),...,(A_{k},B_{k}))$ if and only if there exists some P>0 and Z such that
    ${\begin{aligned}(A+A_{i})P+P(A+A_{i})^{T}+(B+B_{i})Z+Z^{T}(B+B_{i})^{T}<0\quad for\quad i=1,...k.\end{aligned}}$

## Conclusion:

The Controller gain matrix is extracted as $K=ZP^{-1}$
Note that here the controller doesn't depend on $\Delta$
* If you want K to depend on $\Delta$ , the problem is harder.
* But this would require sensing $\Delta$ in real-time.

## Implementation

This implementation requires Yalmip and Sedumi. https://github.com/JalpeshBhadra/LMI/blob/master/quadraticpolytopicstabilization.m

## Related LMIs

Quadratic Polytopic $H_{\infty }$ Controller
Quadratic Polytopic $H_{2}$ Controller

## External Links

* LMI Methods in Optimal and Robust Control - A course on LMIs in Control by Matthew Peet.
* LMI Properties and Applications in Systems, Stability, and Control Theory - A List of LMIs by Ryan Caverly and James Forbes.
* LMIs in Systems and Control Theory - A downloadable book on LMIs by Stephen Boyd.
# Konkani/Family relations

| English | Konkani |
| Mother | ಆವಯ್ ( ಮಾಂಯ್ ) |
| Father | ಬಾಪುಯ್ (ಪಾಯ್/ ಬಾಬ್ / ಆನ್ ) |
| Sister | ಭಯ್ಣ್ |
| Brother | ಭಾವ್ |
| Grandfather | ಆಜೊ ( ಆಬ್ ) |
| Grandmother | ಆಜಿ ( ಮಾಂಯ್) |
| Uncle(Paternal) | ಬಾಪ್ಲೊ ( ಬಾಪ್ಪು ) |
| Aunt(Paternal) | ಆಕಯ್ |
| Uncle (Paternal aunt's Husband) | ಮಾಮ್ |
| Aunt (Paternal uncle's wife) | ಮಾವ್ಶಿ |
| Uncle (Maternal) | ಮಾಮ್ |
| Aunt (Maternal) | ಮಾವ್ಶಿ |
| Uncle (Maternal aunt's husband) | ಬಪ್ಪು |
| Aunt (Maternal uncle's wife) | ಮಾಮಿ |
| Grandson | ನಾತು |
| Granddaughter | ನಾತ್ |
| Grandchildren | ನಾತ್ರಾಂ |
| Father-in-law | ಮಾಂವ್ |
| Mother-in-law | ಸಾಸುಮಾಂಯ್ |
| Brother-in-law (Wife's brother) | ಮಿವ್ಣೊ |
| Sister's husband | ಭಾವೊಜಿ |
| Husband's elder brother | ಭಾವೊ |
| Husbands's younger brother | ದೇರ್ |
| Wife's sister's husband | ಮಿವ್ಣೊ |
| Husband's sister's husband | ಭಾವೊಜಿ |
| Great Grandchild | ಪೊಣ್ತುರ್ |
| Great grandchildren | ಪೊಣ್ತುರಾಂ |
| Great grandfather | ಪೊಣ್ಜೊ |
| Great grandmother | ಪೊಣ್ಜಿ |
| Great great grandchild | ಶೆಣ್ತುರ್ |
| Great great grandchildren | ಶೆಣ್ತುರಾಂ |
| Great great grandfather | ಶೆಣ್ಜೊ |
| Great great grandmother | ಶೆಣ್ಜಿ |
| Sister-in-law (Wife's sister) | ಮಿವ್ಣಿ |
| Husband's Sister | ಬಾವೊಜ್ |
| Brother's wife | ವೊನಿ |
| Elder brother's wife | ವೊನಿ |
| Husband | ಘೊವ್ |
| Wife | ಬಾಯ್ಲ್ |
| Son | ಪೂತ್ |
| Daughter | ಧುವ್ |
| Nephew (Sister's son) | ಭಾಚೊ |
| Niece (Brother's son) | ಪುತ್ಣ್ಯೊ |
| Sister's daughter | ಭಾಚಿ |
| Brother's daughter | ಧುವ್ಡಿ |
| Father-in-law's brother | ಪಗುರ್ಮಾಂವ್ |
| Father-in-law's sister | ಪಗುರ್ಮಾಂಯ್ |
| Bachelor | ಅಂಕ್ವಾರ್ |
| paternal cousins | |
| Maternal cousins | |
| Son-in-law | ಜಾಂವಯ್ |
| Daughter-in-law | ಸುನ್ |
| Father of Son/daughter-in-law | ಯೇಯ್ |
| Mother of Son/daughter-in-law | ಯೇಣ್ |
| Godfather | ಪೊದೊರ್ನ್ |
| Godmother | ಮೊದೊರ್ನ್ |
| Godchild | ಫಿಲ್ಯಾದ್ |
# Konkani
## Table of Contents

* Introduction
* Alphabet

### Chapters

* Greetings
* Talking about oneself
* Asking questions
* Likes and dislikes
* Food and Drink
* Numbers
* Shopping
* Staying at hotels
* Housing
* Letters
* Traveling
* Staying well
* Emergencies
* Zodiac Signs

### Grammar

* Sentence Formation
* Nouns
* Pronouns
* Verbs
* Adjectives
* Adverbs
* Postpositions
* Auxiliaries

### Vocabulary

* Animals
* Birds
* Body parts
* Colors
* Days and Months
* Directions
* Dressing
* Flowers
* Foods
** Grains
* Fruits
* Household objects
* Music and dance
* Plants and trees
* Family relations
* Stationary
* Tools
* Vegetables

### Appendix

* Appendix A: Common phrases
* External references
# Konkani/Directions

| Directions | Konkani Kannada |
| East | ಉದೆಂತ್ (ಪೂರ್ವ್/ಮುಡ್ಲ) |
| West | ಅಸ್ತಮ್ತ್ (ಪಶ್ಚಿಮ್/ಪಡ್ಲಾ) |
| North | ಉತ್ತರ್ (ಬಡ್ಗ) |
| South | ದಕ್ಷಿಣ್ (ತೆಣ್ಕಾ) |
# Konkani/Introduction

Konkani is the official language of Goa, and can also be found in other areas of western India.
# Konkani/External references
## On Wikimedia Commons

* A Konkani Grammar by Angelus Francis Xavier Maffei
* 1885 Konkani-English Dictionary
* Modern English to Konkani Dictionary by Isidore Dantas